Erlang 21

beam_lib




erlang

beam_lib

मॉड्यूल

beam_lib

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

BEAM फ़ाइल स्वरूप के लिए एक इंटरफ़ेस।

विवरण

यह मॉड्यूल BEAM कंपाइलर ("BEAM फ़ाइलें") द्वारा बनाई गई फ़ाइलों के लिए एक इंटरफ़ेस प्रदान करता है। प्रयुक्त प्रारूप, "ईए IFF 1985" का एक संस्करण जो इंटरचेंज प्रारूप फाइलों के लिए मानक है, डेटा को विखंडू में विभाजित करता है।

चंक डेटा को बायनेरिज़ के रूप में या यौगिक शर्तों के रूप में वापस किया जा सकता है। चक्रव्यूह शब्द तब लौटाए जाते हैं जब चॉकर्स को पहचानकर्ताओं (स्ट्रिंग्स) के बजाय नामों (परमाणुओं) द्वारा संदर्भित किया जाता है। मान्यता प्राप्त नाम और संबंधित पहचानकर्ता इस प्रकार हैं:

  • atoms ("Atom")
  • attributes ("Attr")
  • compile_info ("CInf")
  • debug_info ("Dbgi")
  • exports ("ExpT")
  • imports ("ImpT")
  • indexed_imports ("ImpT")
  • labeled_exports ("ExpT")
  • labeled_locals ("LocT")
  • locals ("LocT")

डिबग सूचना / सार कोड

विकल्प debug_info को कंपाइलर ( compile(3) देखें compile(3) ) के लिए डिबग जानकारी के लिए निर्दिष्ट किया जा सकता है, जैसे कि Erlang Abstract Format , debug_info chunk में संग्रहीत है। डीबगर और Xref जैसे टूल को डीबग जानकारी शामिल करने की आवश्यकता होती है।

चेतावनी

स्रोत कोड को डीबग जानकारी से पुन: निर्मित किया जा सकता है। इसे रोकने के लिए, एन्क्रिप्टेड डीबग जानकारी (नीचे देखें) का उपयोग करें।

डिबग सूचना को strip/1 , strip_files/1 और / या strip_release/1 का उपयोग करके BEAM फ़ाइलों से भी हटाया जा सकता है।

स्रोत कोड का पुनर्निर्माण

निम्न उदाहरण दिखाता है कि BEAM फ़ाइल Beam में डीबग जानकारी से Erlang स्रोत कोड का पुनर्निर्माण कैसे करें:

{ok,{_,[{abstract_code,{_,AC}}]}} = beam_lib:chunks(Beam,[abstract_code]).
io:fwrite("~s~n", [erl_prettypr:format(erl_syntax:form_list(AC))]).

डीबग जानकारी एन्क्रिप्ट की गई

स्रोत कोड को गुप्त रखने के लिए डिबग जानकारी को एन्क्रिप्ट किया जा सकता है, लेकिन फिर भी डीबगर या Xref जैसे टूल का उपयोग करने में सक्षम हो सकता है।

एन्क्रिप्टेड डिबग जानकारी का उपयोग करने के लिए, एक कुंजी संकलक और beam_lib को प्रदान की जानी चाहिए। कुंजी को एक स्ट्रिंग के रूप में निर्दिष्ट किया गया है। यह अनुशंसा की जाती है कि स्ट्रिंग में कम से कम 32 अक्षर हों और ऊपरी और निचले दोनों ही प्रकार के अक्षरों के साथ-साथ अंकों और विशेष वर्णों का उपयोग किया जाए।

क्रिप्टो एल्गोरिथ्म का डिफ़ॉल्ट प्रकार (और वर्तमान में एकमात्र प्रकार) des3_cbc , DES के तीन दौर हैं। des3_cbc लिए उपयोग की जाने वाली कुंजियों को उत्पन्न करने के लिए erlang:md5/1 का उपयोग करके कुंजी स्ट्रिंग को स्क्रैम्बल किया जाता है।

ध्यान दें

जहां तक ​​हमें लिखने के समय तक पता है, यह कुंजी के किसी भी ज्ञान के बिना des3_cbc एन्क्रिप्शन को तोड़ने के लिए अलग है। इसलिए, जब तक कुंजी को सुरक्षित रखा जाता है और यह अप्राप्य रहता है, तब तक एन्क्रिप्टेड डीबग जानकारी घुसपैठियों से सुरक्षित होनी चाहिए।

कुंजी को निम्नलिखित दो तरीकों से प्रदान किया जा सकता है:

  • कंपाइलर विकल्प {debug_info_key,Key} उपयोग करें, compile(3) और एक मजेदार पंजीकृत करने के लिए crypto_key_fun/1 को फंक्शन करें, जब भी beam_lib को डीबग सूचना को डिक्रिप्ट करना होगा, तो कुंजी लौटाता है।

    यदि ऐसा कोई मज़ा दर्ज नहीं किया गया है, beam_lib .erlang.crypt फ़ाइल की खोज करने के बजाय, beam_lib अगला अनुभाग देखें।

  • .erlang.crypt नाम की टेक्स्ट फ़ाइल में कुंजी .erlang.crypt

    इस स्थिति में, कंपाइलर विकल्प encrypt_debug_info का उपयोग किया जा सकता है, compile(3)

.erlang.crypt

beam_lib वर्तमान निर्देशिका में .erlang.crypt और फिर वर्तमान उपयोगकर्ता के लिए होम निर्देशिका खोजता है। यदि फ़ाइल पाई जाती है और एक कुंजी होती है, तो beam_lib अंतर्निहित रूप से एक क्रिप्टो कुंजी मज़ा बनाता है और इसे पंजीकृत करता है।

फ़ाइल .erlang.crypt में .erlang.crypt की एकल सूची शामिल है:

{debug_info, Mode, Module, Key}

Mode क्रिप्टो एल्गोरिथ्म का प्रकार है; वर्तमान में, केवल अनुमत मान des3_cbc Module या तो एक परमाणु है, जिस स्थिति में Key केवल मॉड्यूल Module लिए उपयोग की जाती है, या [] , जिस स्थिति में सभी मॉड्यूल के लिए Key का उपयोग किया जाता है। Key गैर-खाली कुंजी स्ट्रिंग है।

पहली ट्यूपल में Key जहां Mode और Module मैच दोनों का उपयोग किया जाता है।

निम्न .erlang.crypt फ़ाइल का एक उदाहरण है जो सभी मॉड्यूल के लिए एक ही कुंजी देता है:

[{debug_info, des3_cbc, [], "%>7}|pc/DM6Cga*68$Mw]L#&_Gejr]G^"}].

निम्नलिखित एक .erlang.crypt का थोड़ा अधिक जटिल उदाहरण है जो मॉड्यूल t लिए एक कुंजी प्रदान करता t और अन्य सभी मॉड्यूल के लिए एक अन्य कुंजी:

[{debug_info, des3_cbc, t, "My KEY"},
 {debug_info, des3_cbc, [], "%>7}|pc/DM6Cga*68$Mw]L#&_Gejr]G^"}].
ध्यान दें

इन उदाहरणों में किसी भी कुंजी का उपयोग न करें। अपनी खुद की चाबी का उपयोग करें।

जानकारी का प्रकार

beam() = module() | file:filename() | binary()

नीचे वर्णित प्रत्येक फ़ंक्शन या तो मॉड्यूल नाम, फ़ाइल नाम या बाइनरी मॉड्यूल युक्त बाइनरी स्वीकार करता है।

chunkdata() =
{ chunkid() , dataB() } |
{abstract_code, abst_code() } |
{debug_info, debug_info() } |
{attributes, [ attrib_entry() ]} |
{compile_info, [ compinfo_entry() ]} |
{exports, [{atom(), arity()}]} |
{labeled_exports, [ labeled_entry() ]} |
{imports, [mfa()]} |
{indexed_imports,
[{ index() , module(), Function :: atom(), arity()}]} |
{locals, [{atom(), arity()}]} |
{labeled_locals, [ labeled_entry() ]} |
{atoms, [{integer(), atom()}]}

विशेषताओं की सूची को विशेषता में वर्गीकृत किया गया है ( attrib_entry() ) और प्रत्येक विशेषता का नाम सूची में एक बार होता है। विशेषता मान फ़ाइल के समान क्रम में होते हैं। कार्यों की सूचियाँ भी क्रमबद्ध हैं।

chunkid() = nonempty_string()

"Attr" | "CInf" | "Dbgi" | "ExpT" | "ImpT" | "लोकेट" | "AtU8"

dataB() = binary()
debug_info() =
{DbgiVersion :: atom(), Backend :: module(), Data :: term()} |
no_debug_info

प्रारूप debug_info चंक में संग्रहीत है। बैकएंड से विशेष कोड प्रतिनिधित्व प्राप्त करने के लिए, Backend:debug_info(Format, Module, Data, Opts) को आमंत्रित किया जाना चाहिए। Format एक परमाणु है, जैसे कि Erlang Abstract Format के लिए core_v1 और Core Erlang के लिए core_v1 Module बीम फ़ाइल द्वारा दर्शाया गया Module है और Data डीबग जानकारी चंक में संग्रहीत मूल्य है। Opts Backend द्वारा समर्थित मूल्यों की किसी भी सूची है। Backend:debug_info/4 को {ok, Code} या {error, Term} वापस करना होगा।

डेवलपर्स को हमेशा debug_info/4 फ़ंक्शन का आह्वान करना चाहिए और कभी भी debug_info chunk में संग्रहीत Data पर भरोसा नहीं करना चाहिए, क्योंकि यह अपारदर्शी है और किसी भी समय बदल सकता है। no_debug_info अर्थ है कि चंक "Dbgi" मौजूद है, लेकिन खाली है।

abst_code() =
{AbstVersion :: atom(), forms() } | no_abstract_code

यह जाँच नहीं की जाती है कि प्रपत्र AbstVersion द्वारा दर्शाए गए अमूर्त प्रारूप के अनुरूप हैं। no_abstract_code अर्थ है कि "Abst" no_abstract_code "Abst" chunk मौजूद है, लेकिन खाली है।

OTP 20 के साथ संकलित मॉड्यूल के लिए, abst_code chunk स्वचालित रूप से debug_info chunk से गणना की जाती है।

compinfo_entry() = {InfoKey :: atom(), term()}
attrib_entry() =
{Attribute :: atom(), [AttributeValue :: term()]}

labeled_entry() = {Function :: atom(), arity(), label() }
index() = integer() >= 0
label() = integer()
chunkname() =
abstract_code |
debug_info |
attributes |
compile_info |
exports |
labeled_exports |
imports |
indexed_imports |
locals |
labeled_locals |
atoms

chnk_rsn() =
{unknown_chunk, file:filename() , atom()} |
{key_missing_or_invalid,
file:filename() ,
abstract_code | debug_info} |
info_rsn()

info_rsn() =
{chunk_too_big,
file:filename() ,
chunkid() ,
ChunkSize :: integer() >= 0,
FileSize :: integer() >= 0} |
{invalid_beam_file,
file:filename() ,
Position :: integer() >= 0} |
{invalid_chunk, file:filename() , chunkid() } |
{missing_chunk, file:filename() , chunkid() } |
{not_a_beam_file, file:filename() } |
{file_error, file:filename() , file:posix() }

निर्यात

all_chunks (फ़ाइल :: beam() ) ->
{ठीक है, बीम_लिब, [{ chunkid() , dataB() }]} |
{एरर, बीम_लिब, info_rsn() }

सभी विखंडू के लिए चंक डेटा पढ़ता है।

build_module (हिस्सा) -> {ठीक है, बाइनरी}

प्रकार

बंक की सूची से एक BEAM मॉड्यूल (एक बाइनरी के रूप में) बनाता है।

चंक्स (बीम, चंकरीफ्स) ->
{ठीक है, {मॉड्यूल (), [ chunkdata() ]}} |
{त्रुटि, बीम_लिब, chnk_rsn() }

प्रकार

चयनित विखंडू संदर्भों के लिए चंक डेटा पढ़ता है। चंक डेटा की लौटी हुई सूची का क्रम चंक्स संदर्भों की सूची के क्रम द्वारा निर्धारित किया जाता है।

चंक्स (बीम, ChunkRefs, विकल्प) ->
{ठीक है, {मॉड्यूल (), [ChunkResult]}} |
{त्रुटि, बीम_लिब, chnk_rsn() }

प्रकार

चयनित विखंडू संदर्भों के लिए चंक डेटा पढ़ता है। चंक डेटा की लौटी हुई सूची का क्रम चंक्स संदर्भों की सूची के क्रम द्वारा निर्धारित किया जाता है।

डिफ़ॉल्ट रूप से, यदि Beam में कोई भी अनुरोधित चंक गायब है, तो एक error ट्यूपल वापस आ जाता है। हालाँकि, यदि विकल्प allow_missing_chunks निर्दिष्ट है, तो एक परिणाम लौटाया जाता है, भले ही विखंडू गायब हों। परिणाम सूची में, किसी भी लापता चंक को {ChunkRef,missing_chunk} रूप में {ChunkRef,missing_chunk} । हालांकि ध्यान दें कि यदि "Atom" गायब है, तो इसे एक घातक त्रुटि माना जाता है और वापसी मान एक error

clear_crypto_key_fun () -> अपरिभाषित | {ठीक है, परिणाम}

प्रकार

क्रिप्टो कुंजी मज़ा रद्द करता है और क्रिप्टो_की_फुन crypto_key_fun/1 द्वारा शुरू की गई प्रक्रिया को रोक देता है।

रिटर्न या तो {ok, undefined} यदि कोई क्रिप्टोकरंसी फन रजिस्टर्ड नहीं है, या {ok, Term} , जहां Term CryptoKeyFun(clear) से रिटर्न वैल्यू है, तो crypto_key_fun/1

cmp (Beam1, Beam2) -> ठीक है | {त्रुटि, बीम_लिब, cmp_rsn ()}

प्रकार

दो BEAM फ़ाइलों की सामग्री की तुलना करता है। यदि मॉड्यूल नाम समान हैं, और चंक "CInf" को छोड़कर सभी विखंडू (संकलन जानकारी है कि Module:module_info(compile) द्वारा लौटाया गया है Module:module_info(compile) "CInf" Module:module_info(compile) ) दोनों फ़ाइलों में एक ही सामग्री है, ok है। अन्यथा एक त्रुटि संदेश वापस आ जाता है।

cmp_dirs (Dir1, Dir2) ->
{केवल 1, केवल 2, अलग} | {त्रुटि, बीम_लिब, कारण}

प्रकार

दो निर्देशिकाओं में BEAM फ़ाइलों की तुलना करता है। केवल ".beam" एक्सटेंशन वाली फ़ाइलों की तुलना की जाती है। BEAM फाइलें जो केवल निर्देशिका में मौजूद हैं Dir1 ( Dir2 ) Dir1 ( Dir2 ) में वापस आ गई हैं। BEAM फाइलें जो दोनों निर्देशिकाओं में मौजूद हैं, लेकिन cmp/2 द्वारा अलग-अलग मानी जाती हैं, उन्हें जोड़े के रूप में लौटाया जाता है { Filename1 , Filename2 }, जहां Filename1 ( Filename2 ) डायरेक्टरी Dir1 ( Dir2 ) में मौजूद है।

crypto_key_fun (CryptoKeyFun) -> ठीक है | {त्रुटि, कारण}

प्रकार

beam_lib एक debug_info मज़ा जिसे beam_lib को beam_lib को पढ़ना चाहिए जिसे एन्क्रिप्ट किया गया है। मज़ा एक प्रक्रिया में आयोजित किया जाता है जो फ़ंक्शन द्वारा शुरू किया जाता है।

यदि एक मजेदार रजिस्टर करने का प्रयास करते समय एक मज़ा पहले से ही पंजीकृत है, तो {error, exists} वापस कर दिया जाता है।

मज़े को निम्नलिखित तर्कों को संभालना होगा:

CryptoKeyFun(init) -> ok | {ok, NewCryptoKeyFun} | {error, Term}

मज़ा पंजीकृत होने पर कॉल किया जाता है, इस प्रक्रिया में जो मज़ा रखती है। यहां क्रिप्टो कुंजी मज़ा किसी भी आवश्यक इनिशियलाइज़ेशन कर सकते हैं। यदि {ok, NewCryptoKeyFun} वापस कर दिया जाता है, तो NewCryptoKeyFun बजाय CryptoKeyFun पंजीकृत है। यदि {error, Term} को लौटा दिया जाता है, तो पंजीकरण रद्द कर दिया जाता है और crypto_key_fun/1 भी {error, Term}

CryptoKeyFun({debug_info, Mode, Module, Filename}) -> Key

Filename नाम की फ़ाइल में मॉड्यूल Module लिए कुंजी की आवश्यकता होने पर कॉल किया जाता है। Mode क्रिप्टो एल्गोरिथ्म का प्रकार है; वर्तमान में, एकमात्र संभव मान des3_cbc । यदि कोई कुंजी उपलब्ध नहीं है, तो कॉल को विफल (अपवाद को उठाना) है।

CryptoKeyFun(clear) -> term()

मज़ा अपंजीकृत होने से पहले बुलाया जाता है। यहां कोई भी सफाई की जा सकती है। वापसी मूल्य महत्वपूर्ण नहीं है, लेकिन इसके वापसी मूल्य के हिस्से के रूप में clear_crypto_key_fun/0 के कॉलर पर वापस भेज दिया जाता है।

diff_dirs (Dir1, Dir2) -> ठीक है | {त्रुटि, बीम_लिब, कारण}

प्रकार

दो निर्देशिकाओं में BEAM फ़ाइलों की तुलना cmp_dirs/2 रूप में की cmp_dirs/2 , लेकिन उन फ़ाइलों के नाम जो केवल एक निर्देशिका में मौजूद हैं या भिन्न हैं जो मानक आउटपुट पर प्रस्तुत की जाती हैं।

format_error (कारण) -> io_lib:chars()

प्रकार

इस मॉड्यूल में किसी फ़ंक्शन द्वारा दी गई निर्दिष्ट त्रुटि के लिए, यह फ़ंक्शन अंग्रेजी में त्रुटि का एक वर्णनात्मक स्ट्रिंग लौटाता है। फ़ाइल त्रुटियों के लिए, फ़ंक्शन file:format_error(Posix) कहा जाना है।

जानकारी (बीम) -> [InfoPair] | {एरर, बीम_लिब, info_rsn() }

प्रकार

एक सूची लौटाती है, जो BEAM फ़ाइल के बारे में कुछ जानकारी बताती है {Item, Info} :

{file, Filename} | {binary, Binary}

BEAM फ़ाइल का नाम (स्ट्रिंग), या बाइनरी जिसमें से जानकारी निकाली गई थी।

{module, Module}

मॉड्यूल का नाम (परमाणु)।

{chunks, [{ChunkId, Pos, Size}]}

प्रत्येक बंक के लिए, बाइट में पहचानकर्ता (स्ट्रिंग) और चंक डेटा की स्थिति और आकार।

md5 (बीम) -> {ठीक है, {मॉड्यूल (), एमडी 5}} | {त्रुटि, बीम_लिब, chnk_rsn() }

प्रकार

मॉड्यूल के कोड के लिए एक एमडी 5 अतिरेक जांच की गणना करता है (संकलन तिथि और अन्य विशेषताओं को शामिल नहीं किया गया है)।

पट्टी (बीम 1) ->
{ठीक है, {मॉड्यूल (), बीईएम २}} | {एरर, बीम_लिब, info_rsn() }

प्रकार

लोडर की जरूरत के अलावा एक बीएएम फ़ाइल से सभी विखंडू को निकालता है। विशेष रूप से, डिबग जानकारी (chunk debug_info और abstract_code ) को हटा दिया जाता है।

पट्टी_फाइल्स (फाइलें) ->
{ठीक है, [{मॉड्यूल (), बीम}]} |
{एरर, बीम_लिब, info_rsn() }

प्रकार

BEAM फ़ाइलों से लोडर द्वारा आवश्यक को छोड़कर सभी विखंडू को हटाता है। विशेष रूप से, डिबग जानकारी (chunk debug_info और abstract_code ) को हटा दिया जाता है। लौटी हुई सूची में प्रत्येक निर्दिष्ट फ़ाइल नाम के लिए एक तत्व होता है, जैसे कि Files

stri_release (Dir) ->
{ठीक है, [{मॉड्यूल (), file:filename() }]} |
{त्रुटि, बीम_लिब, कारण}

प्रकार

एक रिलीज के BEAM फ़ाइलों से लोडर द्वारा आवश्यक को छोड़कर सभी विखंडू को हटाता है। Dir इंस्टालेशन रूट डायरेक्टरी होना है। उदाहरण के लिए, वर्तमान OTP रिलीज़ को कॉल beam_lib:strip_release(code:root_dir()) लिया जा सकता है।

संस्करण (बीम) ->
{ठीक है, {मॉड्यूल (), [संस्करण :: शब्द ()]}} |
{त्रुटि, बीम_लिब, chnk_rsn() }

प्रकार

मॉड्यूल संस्करण या संस्करण लौटाता है। एक संस्करण मॉड्यूल विशेषता -vsn(Vsn) द्वारा परिभाषित किया गया है। यदि यह विशेषता निर्दिष्ट नहीं है, तो संस्करण मॉड्यूल के चेकसम में डिफॉल्ट करता है। ध्यान दें कि यदि संस्करण Vsn एक सूची नहीं है, तो इसे एक में बनाया जाता है, जो कि {ok,{Module,[Vsn]}} है। यदि कई -vsn मॉड्यूल विशेषताएँ हैं, तो परिणाम संस्करणों की -vsn सूची है।

उदाहरण:

1> beam_lib:version(a). % -vsn(1).
{ok,{a,[1]}}
2> beam_lib:version(b). % -vsn([1]).
{ok,{b,[1]}}
3> beam_lib:version(c). % -vsn([1]). -vsn(2).
{ok,{c,[1,2]}}
4> beam_lib:version(d). % no -vsn attribute
{ok,{d,[275613208176997377698094100858909383631]}}