Erlang 21

escript




erlang

escript

आदेश

escript

कमांड सारांश

Erlang स्क्रिप्टिंग समर्थन

विवरण

escript पहले संकलन करने के बिना लघु इरलांग कार्यक्रमों को चलाने के लिए समर्थन प्रदान करता है, और कमांड-लाइन तर्कों को पुनः प्राप्त करने का एक आसान तरीका है।

escript रनटाइम सिस्टम के साथ इसे आत्मनिर्भर और स्थानांतरित करने के लिए escript (एस) को बंडल करना संभव है। इस तरह के एक स्टैंडअलोन सिस्टम में, escript (एस) को स्टैंडअलोन सिस्टम के शीर्ष bin निर्देशिका में स्थित होना चाहिए और फ़ाइल एक्सटेंशन के रूप में .escript को दिया जाना चाहिए। इसके अलावा (बिल्ट-इन) escript प्रोग्राम को एक ही डायरेक्टरी में कॉपी किया जाना चाहिए और स्क्रिप्ट्स को मूल नाम (बिना स्क्रिप्ट एक्सटेंशन के) दिया जाना चाहिए। यह बंडल किए गए एर्लैंग रनटाइम सिस्टम के उपयोग को सक्षम करेगा।

(बिल्ट-इन) escript प्रोग्राम सबसे पहले यह निर्धारित करता है कि एर्लांग रनटाइम सिस्टम का उपयोग करना है और फिर अपनी स्क्रिप्ट को निष्पादित करने के लिए इसे शुरू करता है। आमतौर पर रनटाइम सिस्टम उसी एरलैंग इंस्टॉलेशन में स्थित होता है, जो escript प्रोग्राम के रूप में होता है। लेकिन एक या अधिक एस्किप्ट के साथ स्टैंडअलोन सिस्टम के लिए यह मामला हो सकता है कि आपके रास्ते में एस्क्रिप्ट प्रोग्राम वास्तव में एस्क्रिप्ट के साथ बंडल किए गए रनटाइम सिस्टम को शुरू करता है। यह जानबूझकर है, और आम तौर पर तब होता है जब स्टैंडअलोन सिस्टम bin निर्देशिका निष्पादन पथ में नहीं होता है (जैसा कि इसके वांछित प्रोग्राम को वांछित को ओवरराइड करने का कारण हो सकता है) और escript (एस) को एक bin निर्देशिका से प्रतीकात्मक लिंक के माध्यम से संदर्भित किया जाता है राह।

निर्यात

स्क्रिप्ट-नाम स्क्रिप्ट- arg1 स्क्रिप्ट-arg2 ...
एस्क्रिप्टस्क्रिप्ट-झंडे लिपि-नाम लिपि-arg1 लिपि-arg2 ...

escript में लिखी गई एक स्क्रिप्ट को चलाता है।

उदाहरण:

$ chmod u+x factorial
$ cat factorial
#!/usr/bin/env escript
%% -*- erlang -*-
%%! -smp enable -sname factorial -mnesia debug verbose
main([String]) ->
    try
        N = list_to_integer(String),
        F = fac(N),
        io:format("factorial ~w = ~w\n", [N,F])
    catch
        _:_ ->
            usage()
    end;
main(_) ->
    usage().

usage() ->
    io:format("usage: factorial integer\n"),
    halt(1).

fac(0) -> 1;
fac(N) -> N * fac(N-1).
$ ./factorial 5
factorial 5 = 120
$ ./factorial
usage: factorial integer
$ ./factorial five
usage: factorial integer

उदाहरण में Erlang स्क्रिप्ट का हेडर सामान्य Erlang मॉड्यूल से भिन्न होता है। पहली पंक्ति में दुभाषिया रेखा होने का इरादा है, जो escript आमंत्रित करता है।

हालाँकि, यदि आप निम्नानुसार escript को लागू करते हैं, तो पहली पंक्ति की सामग्री कोई मायने नहीं रखती है, लेकिन इसमें Erlang कोड नहीं हो सकता क्योंकि इसे अनदेखा किया जाएगा:

$ escript factorial 5

उदाहरण में दूसरी पंक्ति में Emacs संपादक के लिए एक वैकल्पिक निर्देश है, जो इसे Erlangs फ़ाइलों को संपादित करने के लिए प्रमुख मोड में प्रवेश करने का कारण बनता है। यदि निर्देश मौजूद है, तो इसे दूसरी पंक्ति पर स्थित होना चाहिए।

यदि encoding चयन करने वाली टिप्पणी मौजूद है, तो यह दूसरी पंक्ति पर स्थित हो सकती है।

ध्यान दें

उपर्युक्त टिप्पणी द्वारा निर्दिष्ट एन्कोडिंग स्क्रिप्ट पर ही लागू होता है। हालाँकि, I / O- सर्वर का एन्कोडिंग स्पष्ट रूप से निम्नानुसार सेट किया जाना चाहिए:

io:setopts([{encoding, unicode}])

मानक_io के लिए I / O- सर्वर का डिफ़ॉल्ट एन्कोडिंग है, जैसे कि STDLIB उपयोगकर्ता के गाइड में गैर-संवादात्मक टर्मिनल ( Summary of Options अनुभाग Summary of Options देखें) में स्क्रिप्ट चलता है।

तीसरी पंक्ति (या Emacs निर्देश की उपस्थिति के आधार पर दूसरी पंक्ति) पर, तर्क एमुलेटर के लिए निर्दिष्ट किए जा सकते हैं: उदाहरण के लिए:

%%! -smp enable -sname factorial -mnesia debug verbose

इस तरह की एक तर्क पंक्ति %%! शुरू होनी चाहिए %%! और शेष रेखा को एमुलेटर के तर्क के रूप में व्याख्या की जाती है।

यदि आप escript निष्पादन योग्य का स्थान जानते हैं, तो पहली पंक्ति सीधे escript को रास्ता दे सकती है, उदाहरण के लिए:

#!/usr/local/bin/escript

किसी भी अन्य प्रकार की स्क्रिप्ट के रूप में, यदि स्क्रिप्ट फ़ाइल के लिए निष्पादन बिट सेट नहीं है, तो Erlang स्क्रिप्ट यूनिक्स प्लेटफार्मों पर काम नहीं करती हैं। (निष्पादन बिट को चालू करने के लिए, chmod +x script-name उपयोग chmod +x script-name ।)

शेष Erlang स्क्रिप्ट फ़ाइल में या तो Erlang स्रोत कोड , एक इनलाइन बीम फ़ाइल , या एक इनबिल्ड आर्काइव फ़ाइल हो सकती है

Erlang स्क्रिप्ट फ़ाइल में हमेशा main/1 फ़ंक्शन होना चाहिए। जब स्क्रिप्ट चलती है, तो main/1 फ़ंक्शन को स्क्रिप्ट में निर्दिष्ट तर्कों का प्रतिनिधित्व करने वाले तारों की एक सूची के साथ कहा जाता है (किसी भी तरह से परिवर्तित या व्याख्या नहीं की गई)।

यदि स्क्रिप्ट में main/1 फ़ंक्शन सफलतापूर्वक लौटता है, तो स्क्रिप्ट की निकास स्थिति 0 । यदि निष्पादन के दौरान एक अपवाद उत्पन्न होता है, तो एक लघु संदेश मुद्रित होता है और स्क्रिप्ट निकास स्थिति 127 साथ समाप्त हो जाती है।

अपने स्वयं के शून्य-शून्य निकास कोड को वापस करने के लिए, उदाहरण के लिए halt(ExitCode) कॉल करें:

halt(1).

स्क्रिप्ट के पथनाम को पुनः प्राप्त करने के लिए, अपनी स्क्रिप्ट से स्क्रिप्ट escript:script_name() कॉल करें (पथनाम आमतौर पर है, लेकिन हमेशा नहीं, निरपेक्ष)।

यदि फ़ाइल में स्रोत कोड होता है (जैसा कि ऊपर दिए गए उदाहरण में है), तो यह epp प्रीप्रोसेसर द्वारा संसाधित होता है। इसका मतलब है कि आप, उदाहरण के लिए, पूर्वनिर्धारित मैक्रोज़ (जैसे ?MODULE ) का उपयोग कर सकते हैं और -include_lib निर्देश जैसे निर्देश -include_lib । उदाहरण के लिए, उपयोग करें

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

फ़ंक्शन file:read_link_info/1 द्वारा उपयोग किए गए रिकॉर्ड के लिए रिकॉर्ड परिभाषाओं को शामिल करने के लिए file:read_link_info/1 । आप यहां एक एन्कोडिंग टिप्पणी को शामिल करके एन्कोडिंग का चयन भी कर सकते हैं, लेकिन यदि दूसरी लाइन पर एक वैध एन्कोडिंग टिप्पणी मौजूद है, तो यह पूर्ववर्तीता लेता है।

स्क्रिप्ट को रन करने से पहले सिंटेक्टिक और सिमेंटिक शुद्धता के लिए जाँच की जाती है। यदि चेतावनी (जैसे अप्रयुक्त चर) हैं, तो वे मुद्रित हैं और स्क्रिप्ट अभी भी चलाई जाएगी। यदि त्रुटियां हैं, तो उन्हें मुद्रित किया जाता है और स्क्रिप्ट नहीं चलाई जाएगी और इसकी निकास स्थिति 127

मॉड्यूल घोषणा और main/1 फ़ंक्शन के निर्यात घोषणा वैकल्पिक हैं।

डिफ़ॉल्ट रूप से, स्क्रिप्ट की व्याख्या की जाएगी। आप इसे स्क्रिप्ट फ़ाइल में कहीं निम्नलिखित पंक्ति को शामिल करके संकलित करने के लिए मजबूर कर सकते हैं:

-mode(compile).

संकलित कोड की तुलना में व्याख्या किए गए कोड का निष्पादन धीमा है। यदि निष्पादन कोड में बहुत कुछ होता है, तो इसे संकलित करने के लिए सार्थक हो सकता है, हालांकि संकलन स्वयं थोड़ी देर लेता है। साथ ही, compile बजाय native की आपूर्ति की जा सकती है। यह मूल ध्वज का उपयोग करके स्क्रिप्ट को संकलित करता है और हो सकता है कि यह एस्केलेटर विशेषताओं के आधार पर सार्थक हो या नहीं।

जैसा कि पहले उल्लेख किया गया है, एक स्क्रिप्ट में पूर्वनिर्धारित beam कोड हो सकता है। एक precompiled स्क्रिप्ट में, स्क्रिप्ट हेडर की व्याख्या उसी तरह होती है जैसे किसी स्क्रिप्ट में सोर्स कोड होता है। इसका अर्थ है कि आप फ़ाइल को #! शुरू होने वाली लाइनों के साथ जोड़कर एक beam फ़ाइल को निष्पादन योग्य बना सकते हैं #! और %%! उपर्युक्त। एक precompiled स्क्रिप्ट में, main/1 फ़ंक्शन को निर्यात किया जाना चाहिए।

एक अन्य विकल्प स्क्रिप्ट में संपूर्ण एरलंग संग्रह है। एक आर्काइव स्क्रिप्ट में, स्क्रिप्ट हेडर की व्याख्या उसी तरह होती है जैसे किसी स्क्रिप्ट में सोर्स कोड होता है। इसका मतलब है कि आप #! साथ शुरू होने वाली लाइनों के साथ फ़ाइल को तैयार करके एक आर्काइव फ़ाइल को निष्पादन योग्य बना सकते हैं #! और %%! उपर्युक्त। एक संग्रह स्क्रिप्ट में, main/1 फ़ंक्शन को निर्यात किया जाना चाहिए। डिफ़ॉल्ट रूप से मॉड्यूल में main/1 फ़ंक्शन उसी नाम के साथ होता है जैसा कि escript फाइल का escript है। ध्वज- -escript main Module को एमुलेटर झंडे के रूप में सेट करके इस व्यवहार को ओवरराइड किया जा सकता है। Module एक मॉड्यूल का नाम होना चाहिए जिसका निर्यात main/1 फ़ंक्शन है। अभिलेखागार और कोड लोडिंग के बारे में अधिक जानकारी के लिए, code(3)

अक्सर एस्क्रिप्ट में हेडर रखना बहुत सुविधाजनक होता है, विशेषकर यूनिक्स प्लेटफार्मों पर। हालाँकि, हेडर वैकल्पिक है, इसलिए आप सीधे किसी भी हेडर को जोड़ने के बिना एर्लैंग मॉड्यूल, बीम फ़ाइल या संग्रह फ़ाइल को "निष्पादित" कर सकते हैं। लेकिन फिर आपको स्क्रिप्ट को निम्नानुसार करना होगा:

$ escript factorial.erl 5
factorial 5 = 120
$ escript factorial.beam 5
factorial 5 = 120
$ escript factorial.zip 5
factorial 5 = 120
escript: create (FileOrBin, Sections) -> ok | {ठीक है, बाइनरी ()} | {त्रुटिपूर्ण शर्त()}

प्रकार

अनुभागों की सूची से एक एस्क्रिप्ट बनाता है। वर्गों को किसी भी क्रम में निर्दिष्ट किया जा सकता है। एक एस्क्रिप्ट एक अनिवार्य Header साथ शुरू होता है और उसके बाद एक अनिवार्य Body । यदि शीर्ष लेख मौजूद है, तो यह हमेशा एक emu_args साथ शुरू होता है, संभवतः एक comment और emu_args shebang "/usr/bin/env escript" डिफॉल्ट करता है। comment "This is an -*- erlang -*- file" । बनाई गई एस्क्रिप्ट को या तो बाइनरी के रूप में वापस किया जा सकता है या फ़ाइल में लिखा जा सकता है।

एक उदाहरण के रूप में कि फ़ंक्शन का उपयोग कैसे किया जा सकता है, हम एक व्याख्यात्मक emu_args बनाते हैं जो कुछ एमुलेटर फ्लैग सेट करने के लिए emu_args का उपयोग करता है। इस स्थिति में, यह smp_support को अक्षम करने के लिए होता है। हम नई बनाई गई स्क्रिप्ट से विभिन्न खंड भी निकालते हैं:

> Source = "%% Demo\nmain(_Args) ->\n io:format(erlang:system_info(smp_support)).\n".
"%% Demo\nmain(_Args) ->\n    io:format(erlang:system_info(smp_support)).\n"
> io:format("~s\n", [Source]).
%% Demo
main(_Args) ->
    io:format(erlang:system_info(smp_support)).

ok
> {ok, Bin} = escript:create(binary, [shebang, comment, {emu_args, "-smp disable"}, {source, list_to_binary(Source)}]).
{ok,<<"#!/usr/bin/env escript\n%% This is an -*- erlang -*- file\n%%!-smp disabl"...>>}
> file:write_file("demo.escript", Bin).
ok
> os:cmd("escript demo.escript").
"false"
> escript:extract("demo.escript", []).
{ok,[{shebang,default}, {comment,default}, {emu_args,"-smp disable"},
     {source,<<"%% Demo\nmain(_Args) ->\n    io:format(erlang:system_info(smp_su"...>>}]}

हेडर के बिना एक एस्केस्क्रिप्ट इस प्रकार बनाया जा सकता है:

> file:write_file("demo.erl", ["%% demo.erl\n-module(demo).\n-export([main/1]).\n\n", Source]).
ok
> {ok, _, BeamCode} = compile:file("demo.erl", [binary, debug_info]).
{ok,demo,
    <<70,79,82,49,0,0,2,208,66,69,65,77,65,116,111,109,0,0,0,
      79,0,0,0,9,4,100,...>>}
> escript:create("demo.beam", [{beam, BeamCode}]).
ok
> escript:extract("demo.beam", []).
{ok,[{shebang,undefined}, {comment,undefined}, {emu_args,undefined},
     {beam,<<70,79,82,49,0,0,3,68,66,69,65,77,65,116,
             111,109,0,0,0,83,0,0,0,9,...>>}]}
> os:cmd("escript demo.beam").
"true"

यहां हम एक संग्रह स्क्रिप्ट बनाते हैं जिसमें Erlang कोड और बीम कोड दोनों हैं, फिर हम आर्काइव में सभी फाइलों पर पुनरावृति करते हैं और उनकी सामग्री और उनके बारे में कुछ जानकारी एकत्र करते हैं:

> {ok, SourceCode} = file:read_file("demo.erl").
{ok,<<"%% demo.erl\n-module(demo).\n-export([main/1]).\n\n%% Demo\nmain(_Arg"...>>}
> escript:create("demo.escript", [shebang, {archive, [{"demo.erl", SourceCode}, {"demo.beam", BeamCode}], []}]).
ok
> {ok, [{shebang,default}, {comment,undefined}, {emu_args,undefined}, {archive, ArchiveBin}]} = escript:extract("demo.escript", []).
{ok,[{shebang,default}, {comment,undefined}, {emu_args,undefined},
     {{archive,<<80,75,3,4,20,0,0,0,8,0,118,7,98,60,105,
                152,61,93,107,0,0,0,118,0,...>>}]}
> file:write_file("demo.zip", ArchiveBin).
ok
> zip:foldl(fun(N, I, B, A) -> [{N, I(), B()} | A] end, [], "demo.zip").
{ok,[{"demo.beam",
      {file_info,748,regular,read_write,
                 {{2010,3,2},{0,59,22}},
                 {{2010,3,2},{0,59,22}},
                 {{2010,3,2},{0,59,22}},
                 54,1,0,0,0,0,0},
      <<70,79,82,49,0,0,2,228,66,69,65,77,65,116,111,109,0,0,0,
        83,0,0,...>>},
     {"demo.erl",
      {file_info,118,regular,read_write,
                 {{2010,3,2},{0,59,22}},
                 {{2010,3,2},{0,59,22}},
                 {{2010,3,2},{0,59,22}},
                 54,1,0,0,0,0,0},
      <<"%% demo.erl\n-module(demo).\n-export([main/1]).\n\n%% Demo\nmain(_Arg"...>>}]}
एस्क्रिप्ट: अर्क (फाइल, विकल्प) -> {ठीक है, अनुभाग} | {त्रुटिपूर्ण शर्त()}

प्रकार

एक अनुलेख को पार्स करता है और इसके खंड निकालता है। यह create/2 का उल्टा है।

सभी अनुभागों को तब भी लौटाया जाता है, जब वे एस्क्रिप्ट में मौजूद नहीं होते हैं। यदि किसी विशेष खंड में डिफ़ॉल्ट मान के समान मान होता है, तो निकाला गया मान परमाणु default सेट होता default । यदि कोई खंड अनुपलब्ध है, तो निकाले गए मान को undefined सेट किया जाता है।

विकल्प compile_source केवल तभी परिणाम को प्रभावित करता है जब escript में source कोड होता है। इस स्थिति में Erlang कोड स्वचालित रूप से संकलित किया जाता है और {source, SourceCode} बजाय {source, BeamCode} को वापस कर दिया जाता है।

उदाहरण:

> escript:create("demo.escript", [shebang, {archive, [{"demo.erl", SourceCode}, {"demo.beam", BeamCode}], []}]).
ok
> {ok, [{shebang,default}, {comment,undefined}, {emu_args,undefined}, {archive, ArchiveBin}]} = escript:extract("demo.escript", []).
{ok,[{{archive,<<80,75,3,4,20,0,0,0,8,0,118,7,98,60,105,
                152,61,93,107,0,0,0,118,0,...>>}
     {emu_args,undefined}]}
escript: script_name () -> फ़ाइल

प्रकार

निष्पादित की गई एस्क्रिप्ट का नाम देता है। यदि फ़ंक्शन को एस्क्रिप्ट के संदर्भ के बाहर लागू किया जाता है, तो व्यवहार अपरिभाषित होता है।

विकल्प द्वारा स्वीकृत विकल्प

-c
मोड विशेषता के मूल्य की परवाह किए बिना एस्केलेट को संकलित करता है।
-d
एस्क्यूट को डिबग करता है। डीबगर प्रारंभ करता है, डीबगर में main/1 फ़ंक्शन वाले मॉड्यूल को लोड करता है, main/1 में एक ब्रेकपॉइंट सेट करता है, और main/1 इनवॉइस करता है। यदि मॉड्यूल पहले से तैयार है, तो इसे विकल्प debug_info साथ स्पष्ट रूप से संकलित किया जाना चाहिए।
-i
मोड विशेषता के मूल्य की परवाह किए बिना ईस्क्रिप्ट की व्याख्या करता है।
-s
स्क्रिप्ट फ़ाइल का एक सिंटैक्टिक और सिमेंटिक चेक करता है। चेतावनी और त्रुटियां (यदि कोई हैं) मानक आउटपुट को लिखी जाती हैं, लेकिन स्क्रिप्ट नहीं चलेगी। यदि कोई त्रुटि पाई जाती है, तो निकास स्थिति 0 है, अन्यथा 127
-n
फ्लैग +native का उपयोग करके एस्क्रिप्ट को संकलित करता +native