Erlang 21

ei




erlang

ei

C लाइब्रेरी

Ei

लाइब्रेरी सारांश

Erlang बाइनरी टर्म फॉर्मेट को संभालने के लिए रूटीन।

विवरण

लाइब्रेरी ei में एरलांग बाइनरी टर्म प्रारूप को एनकोड करने और डीकोड करने के लिए मैक्रोज़ और फ़ंक्शन शामिल हैं।

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

ei सी-नोड्स, C-प्रोग्राम्स भी हैंडल करता है जो Erlang वितरण प्रारूप का उपयोग करके Erlang नोड्स (या अन्य C-नोड्स) के साथ Erlang वितरण की बात करता है। ei और erl_interface बीच का अंतर यह है कि ei द्विआधारी प्रारूप का उपयोग सीधे भेजने और प्राप्त करने की शर्तों के दौरान करता है। यह थ्रेड सुरक्षित भी है, और थ्रेड्स का उपयोग करके, एक प्रक्रिया कई सी-नोड्स को संभाल सकती है। erl_interface लाइब्रेरी को ei शीर्ष पर बनाया गया है, लेकिन विरासत कारणों से, यह कई सी-नोड्स के लिए अनुमति नहीं देता है। सामान्य तौर पर, ei सी-नोड्स करने का पसंदीदा तरीका है।

डीकोड और एनकोड फ़ंक्शन बफर में एक इंडेक्स और एक इंडेक्स का उपयोग करते हैं, जो उस बिंदु पर इंगित करता है जहां एनकोड और डीकोड करना है। शब्द एन्कोडेड / डीकोड होने के बाद इंडेक्स को दाईं ओर इंगित करने के लिए अपडेट किया जाता है। कोई जाँच नहीं की जाती है कि यह शब्द बफर में फिट बैठता है या नहीं। यदि एन्कोडिंग बफर के बाहर जाती है, तो प्रोग्राम क्रैश हो सकता है।

सभी कार्य दो पैरामीटर लेते हैं:

  • buf बफर के लिए एक संकेतक है जहां बाइनरी डेटा है या होगा।

  • index बफर में एक इंडेक्स के लिए एक संकेतक है। यह पैरामीटर डीकोडेड / एन्कोडेड शब्द के आकार के साथ बढ़ा हुआ है।

इस प्रकार डेटा buf[*index] जब एक ei फ़ंक्शन कहलाता है।

सभी एनकोड फ़ंक्शन यह मानते हैं कि डेटा के लिए buf और index पैरामीटर एक बड़े बफर को इंगित करते हैं। एन्कोडिंग शब्द का आकार प्राप्त करने के लिए, इसे एन्कोडिंग के बिना, बफ़र पॉइंटर के बजाय NULL पास करें। पैरामीटर index बढ़ा हुआ है, लेकिन कुछ भी एनकोड नहीं किया जाएगा। यह ei में "प्रीफ़लाइट" टर्म एन्कोडिंग का तरीका है।

डायनेमिक बफ़र का उपयोग करने वाले एन्कोड फ़ंक्शन भी हैं। डेटा को एन्कोड करने के लिए इनका उपयोग करना अक्सर अधिक सुविधाजनक होता है। सभी एन्कोड फ़ंक्शन दो संस्करणों में आते हैं; ei_x से शुरू होने वाले लोग एक गतिशील बफर का उपयोग करते हैं।

सभी फ़ंक्शन 0 वापस आते हैं यदि सफल, अन्यथा -1 (उदाहरण के लिए, यदि एक शब्द अपेक्षित प्रकार का नहीं है, या डिकोड करने के लिए डेटा एक अमान्य एर्लांग शब्द है)।

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

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

erlang_char_encoding
typedef enum {
    ERLANG_ASCII = 1,
    ERLANG_LATIN1 = 2,
    ERLANG_UTF8 = 4
} erlang_char_encoding;

परमाणुओं के लिए प्रयुक्त चरित्र एनकोडिंग। ERLANG_ASCII 7-बिट ASCII का प्रतिनिधित्व करता है। लैटिन -1 और यूटीएफ -8 7-बिट एएससीआईआई के विभिन्न विस्तार हैं। सभी 7-बिट ASCII वर्ण मान्य लैटिन -1 और UTF-8 वर्ण हैं। ASCII और लैटिन -1 दोनों एक-एक बाइट द्वारा प्रत्येक वर्ण का प्रतिनिधित्व करते हैं। UTF-8 वर्ण में 1-4 बाइट्स हो सकते हैं। ध्यान दें कि ये स्थिरांक बिट-फ्लैग हैं और इन्हें बिटवाइज़ OR के साथ जोड़ा जा सकता है।

निर्यात

int ei_decode_atom(const char *buf, int *index, char *p)

द्विआधारी प्रारूप से एक परमाणु को डिकोड करता है। परमाणु का पूर्ण-पृथक नाम p पर रखा गया है। अधिकतम MAXATOMLEN बाइट्स को बफर में रखा जा सकता है।

int ei_decode_atom_as(const char *buf, int *index, char *p, int plen, erlang_char_encoding want, erlang_char_encoding* was, erlang_char_encoding* result)

द्विआधारी प्रारूप से एक परमाणु को डिकोड करता है। परमाणु का पूर्ण-पृथक नाम बफर plen बाइट्स के p पर बफर में रखा गया है।

वांछित स्ट्रिंग एन्कोडिंग वांछित द्वारा निर्दिष्ट की गई है। द्विआधारी प्रारूप (लैटिन -1 या UTF-8) में प्रयुक्त मूल एन्कोडिंग को *was से प्राप्त किया जा सकता *was । परिणामी स्ट्रिंग (7-बिट ASCII, लैटिन -1 या UTF-8) की एन्कोडिंग *result से प्राप्त की जा सकती है। दोनों was और result NULL हो सकता NULL । यदि आप want कि ERLANG_LATIN1|ERLANG_UTF8 या यदि *result शुद्ध 7-बिट ASCII (लैटिन-1 और UTF-8 दोनों के साथ संगत) हो, तो *result भिन्न हो सकते हैं।

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

इस समारोह में Erlang / OTP R16 को UTF-8 परमाणुओं के समर्थन के लिए पहले चरण के भाग के रूप में पेश किया गया था।

int ei_decode_bignum(const char *buf, int *index, mpz_t obj)

द्विआधारी प्रारूप में एक पूर्णांक को एक जीएमपी mpz_t पूर्णांक में mpz_t । इस फ़ंक्शन का उपयोग करने के लिए, ei लाइब्रेरी को कॉन्फ़िगर किया जाना चाहिए और जीएमपी लाइब्रेरी का उपयोग करने के लिए संकलित किया जाना चाहिए।

int ei_decode_binary(const char *buf, int *index, void *p, long *len)

द्विआधारी को द्विआधारी प्रारूप से अलग करता है। पैरामीटर len बाइनरी के वास्तविक आकार पर सेट है। ध्यान दें कि ei_decode_binary() मानता है कि बाइनरी के लिए पर्याप्त जगह है। आवश्यक आकार ei_get_type() द्वारा प्राप्त किया जा सकता है।

int ei_decode_boolean(const char *buf, int *index, int *p)

द्विआधारी प्रारूप से एक बूलियन मूल्य को डिकोड करता है। एक बूलियन वास्तव में एक परमाणु है, true डिकोड 1 और false डिकोड 0 हैं।

int ei_decode_char(const char *buf, int *index, char *p)

द्विआधारी प्रारूप से 0-255 के बीच एक चार्ट (8-बिट) पूर्णांक को डिकोड करता है। ऐतिहासिक कारणों से लौटा हुआ पूर्णांक प्रकार char । आपका सी कोड लौटाए गए मूल्य पर विचार करने के लिए है, भले ही सी संकलक और सिस्टम हस्ताक्षर किए जाने के लिए परिभाषित कर सकते हैं।

int ei_decode_double(const char *buf, int *index, double *p)

द्विआधारी प्रारूप से एक डबल-परिशुद्धता (64-बिट) फ़्लोटिंग पॉइंट संख्या को डिकोड करता है।

int ei_decode_ei_term(const char* buf, int* index, ei_term* term)

किसी भी शब्द को डिकोड करता है, या कम से कम करने की कोशिश करता है। यदि शब्द बुफ़ में इंगित किया गया है *index में buf term संघ में फिट बैठता है, तो इसे डिकोड किया जाता है, और term->value में उपयुक्त फ़ील्ड सेट किया जाता है, और *index शब्द के आकार से बढ़ जाता है।

फ़ंक्शन सफल डिकोडिंग पर 1 , त्रुटि पर -1 और 0 शब्द ठीक होने पर रिटर्न देता है, लेकिन term संरचना में फिट नहीं होता है। यदि 1 वापस किया जाता है, तो index में वृद्धि होती है, और term में डिकोड किया गया शब्द होता है।

term संरचना में एक ट्यूल या सूची के लिए एक बाइनरी, स्ट्रिंग या परमाणु के लिए आकार होता है। इसमें एक शब्द है यदि यह निम्न में से कोई है: पूर्णांक, फ्लोट, परमाणु, पिड, पोर्ट या रेफ।

int ei_decode_fun(const char *buf, int *index, erlang_fun *p) void free_fun(erlang_fun* f)

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

int ei_decode_list_header(const char *buf, int *index, int *arity)

बाइनरी प्रारूप से एक सूची शीर्ष लेख को डिकोड करता है। तत्वों की संख्या को वापस लौटाया जाता है। arity+1 तत्व अनुसरण करते हैं (अंतिम एक सूची की पूंछ है, सामान्य रूप से एक खाली सूची)। यदि arity 0 , तो यह एक खाली सूची है।

ध्यान दें कि सूची को स्ट्रिंग के रूप में एन्कोड किया गया है यदि वे पूरी तरह से पूर्णांक में 0..255 से मिलकर होते हैं। यह फ़ंक्शन ऐसे स्ट्रिंग्स को डीकोड नहीं करता है, इसके बजाय ei_decode_string() उपयोग करें।

int ei_decode_long(const char *buf, int *index, long *p)

द्विआधारी प्रारूप से एक लंबे पूर्णांक को डिकोड करता है। यदि कोड 64 बिट्स है, तो फ़ंक्शन ei_decode_long() के समान है।

int ei_decode_longlong(const char *buf, int *index, long long *p)

बाइनरी प्रारूप से एक जीसीसी long long या दृश्य C ++ __int64 (64-बिट) पूर्णांक को __int64 करता है। यह फ़ंक्शन VxWorks पोर्ट में अनुपलब्ध है।

int ei_decode_map_header(const char *buf, int *index, int *arity)

द्विआधारी प्रारूप से एक मैप हेडर को डिकोड करता है। की-वैल्यू पेयर की संख्या *arity में वापस आ जाती है। कुंजी और मान इस क्रम में अनुसरण करते हैं: K1, V1, K2, V2, ..., Kn, Vn । इससे कुल arity*2 शब्द arity*2 हैं। यदि arity शून्य है, तो यह एक खाली नक्शा है। सही ढंग से एन्कोड किए गए नक्शे में डुप्लिकेट कुंजियाँ नहीं हैं।

int ei_decode_pid(const char *buf, int *index, erlang_pid *p)

द्विआधारी प्रारूप से एक प्रक्रिया पहचानकर्ता (पीआईडी) को डिकोड करता है।

int ei_decode_port(const char *buf, int *index, erlang_port *p)

बाइनरी फॉर्मेट से पोर्ट आइडेंटिफ़ायर को डिकोड करता है।

int ei_decode_ref(const char *buf, int *index, erlang_ref *p)

द्विआधारी प्रारूप से एक संदर्भ को डिकोड करता है।

int ei_decode_string(const char *buf, int *index, char *p)

द्विआधारी प्रारूप से एक स्ट्रिंग को डिकोड करता है। Erlang में एक स्ट्रिंग 0 और 255 के बीच पूर्णांकों की एक सूची है। ध्यान दें कि जैसा कि स्ट्रिंग सिर्फ एक सूची है, कभी-कभी सूचियों को term_to_binary/1 द्वारा स्ट्रिंग्स के रूप में एन्कोड किया जाता है, भले ही यह इरादा नहीं था।

स्ट्रिंग को p कॉपी किया गया है, और पर्याप्त स्थान आवंटित किया जाना चाहिए। लौटा स्ट्रिंग NULL -minminated है, इसलिए आपको स्मृति आवश्यकता के लिए एक अतिरिक्त बाइट जोड़ना होगा।

int ei_decode_term(const char *buf, int *index, void *t)

द्विआधारी प्रारूप से एक शब्द घोषित करता है। यह शब्द ETERM* रूप में t में ETERM* , इसलिए t वास्तव में ETERM** ( erl_eterm देखें) है। इस शब्द को बाद में निपटाया जाना है।

ध्यान दें कि यह फ़ंक्शन Erl_Interface लाइब्रेरी में स्थित है।

int ei_decode_trace(const char *buf, int *index, erlang_trace *p)

बाइनरी प्रारूप से एक एरलैंग ट्रेस टोकन को डिकोड करता है।

int ei_decode_tuple_header(const char *buf, int *index, int *arity)

टपल हेडर को डिकोड करता है, तत्वों की संख्या को arity में लौटाया जाता है। टपल तत्व बफर में क्रम से चलते हैं।

int ei_decode_ulong(const char *buf, int *index, unsigned long *p)

बाइनरी प्रारूप से एक अहस्ताक्षरित लंबे पूर्णांक को डिकोड करता है। यदि कोड 64 बिट्स है, तो फ़ंक्शन ei_decode_ulong() के समान है।

int ei_decode_ulonglong(const char *buf, int *index, unsigned long long *p)

बाइनरी प्रारूप से जीसीसी unsigned long long या दृश्य C ++ को unsigned __int64 (64-बिट) पूर्णांक unsigned __int64 । यह फ़ंक्शन VxWorks पोर्ट में अनुपलब्ध है।

int ei_decode_version(const char *buf, int *index, int *version)

Erlang बाइनरी टर्म फॉर्मेट के लिए संस्करण मैजिक नंबर को डिकोड करता है। यह बाइनरी टर्म में पहला टोकन होना चाहिए।

int ei_encode_atom(char *buf, int *index, const char *p) int ei_encode_atom_len(char *buf, int *index, const char *p, int len) int ei_x_encode_atom(ei_x_buff* x, const char *p) int ei_x_encode_atom_len(ei_x_buff* x, const char *p, int len)

बाइनरी प्रारूप में एक परमाणु को एनकोड करता है। पैरामीटर p लैटिन -1 एन्कोडिंग में परमाणु का नाम है। केवल MAXATOMLEN-1 बाइट तक एन्कोडेड हैं। नाम को पूर्ण-रहित होना NULL , केवल ei_x_encode_atom_len() फ़ंक्शन को छोड़कर।

int ei_encode_atom_as(char *buf, int *index, const char *p, erlang_char_encoding from_enc, erlang_char_encoding to_enc) int ei_encode_atom_len_as(char *buf, int *index, const char *p, int len, erlang_char_encoding from_enc, erlang_char_encoding to_enc) int ei_x_encode_atom_as(ei_x_buff* x, const char *p, erlang_char_encoding from_enc, erlang_char_encoding to_enc) int ei_x_encode_atom_len_as(ei_x_buff* x, const char *p, int len, erlang_char_encoding from_enc, erlang_char_encoding to_enc)

बाइनरी प्रारूप में एक परमाणु को एनकोड करता है। पैरामीटर p परमाणु के नाम से वर्ण एन्कोडिंग से है (ASCII, लैटिन -1, या UTF-8)। नाम या तो NULL -minminated होना चाहिए या एक फ़ंक्शन पैरामीटर जिसके साथ एक len पैरामीटर का उपयोग किया जाना चाहिए।

एन्कोडिंग विफल रहता है यदि p एन्कोडिंग from_enc एक मान्य स्ट्रिंग नहीं है।

तर्क to_enc को नजरअंदाज किया जाता है। Erlang / OTP 20 से एन्कोडिंग हमेशा UTF-8 में किया जाता है जो कि Erlang / OTP R16 जितना पुराना होता है।

int ei_encode_bignum(char *buf, int *index, mpz_t obj) int ei_x_encode_bignum(ei_x_buff *x, mpz_t obj)

बाइनरी प्रारूप में एक जीएमपी mpz_t पूर्णांक mpz_t करता है। इस फ़ंक्शन का उपयोग करने के लिए, ei लाइब्रेरी को कॉन्फ़िगर किया जाना चाहिए और जीएमपी लाइब्रेरी का उपयोग करने के लिए संकलित किया जाना चाहिए।

int ei_encode_binary(char *buf, int *index, const void *p, long len) int ei_x_encode_binary(ei_x_buff* x, const void *p, long len)

बाइनरी को बाइनरी फॉर्मेट में एनकोड करता है। डेटा p बाइट्स लंबाई के p पर है।

int ei_encode_boolean(char *buf, int *index, int p) int ei_x_encode_boolean(ei_x_buff* x, int p)

यदि शून्य शून्य है, या false यदि p शून्य है, तो परमाणु मूल्य के रूप में एक बूलियन मान को एनकोड करता है।

int ei_encode_char(char *buf, int *index, char p) int ei_x_encode_char(ei_x_buff* x, char p)

द्विआधारी प्रारूप में 0-255 के बीच पूर्णांक के रूप में एक चार्ट (8-बिट) को एनकोड करता है। ऐतिहासिक कारणों से पूर्णांक तर्क प्रकार char । आपका सी कोड निर्दिष्ट तर्क पर विचार करने के लिए है, भले ही सी संकलक और प्रणाली हस्ताक्षर किए जाने के लिए परिभाषित कर सकते हैं, भले ही टाइप करें।

int ei_encode_double(char *buf, int *index, double p) int ei_x_encode_double(ei_x_buff* x, double p)

द्विआधारी प्रारूप में एक डबल-परिशुद्धता (64-बिट) फ़्लोटिंग पॉइंट संख्या को एनकोड करता है।

रिटर्न -1 अगर फ्लोटिंग पॉइंट नंबर परिमित नहीं है।

int ei_encode_empty_list(char* buf, int* index) int ei_x_encode_empty_list(ei_x_buff* x)

एक खाली सूची को एनकोड करता है। यह अक्सर एक सूची की पूंछ पर प्रयोग किया जाता है।

int ei_encode_fun(char *buf, int *index, const erlang_fun *p) int ei_x_encode_fun(ei_x_buff* x, const erlang_fun* fun)

बाइनरी प्रारूप में एक मजेदार एनकोड करता है। पैरामीटर p एक erlang_fun संरचना की ओर erlang_fun करता है। erlang_fun को स्वचालित रूप से मुक्त नहीं किया जाता है, एन्कोडिंग के बाद मज़ा की आवश्यकता नहीं होने पर free_fun को बुलाया जाना चाहिए।

int ei_encode_list_header(char *buf, int *index, int arity) int ei_x_encode_list_header(ei_x_buff* x, int arity)

एक निर्दिष्ट शीर्षता के साथ, सूची शीर्षलेख को एनकोड करता है। अगली arity+1 पद तत्व हैं (वास्तव में इसकी arity cons cells) और सूची की पूंछ। सूचियों और टुपल्स को पुनरावर्ती रूप से एन्कोड किया जाता है, ताकि एक सूची में दूसरी सूची या टपल हो सके।

उदाहरण के लिए, सूची को संलग्न करने के लिए [c, d, [e | f]] [c, d, [e | f]] :

ei_encode_list_header(buf, &i, 3);
ei_encode_atom(buf, &i, "c");
ei_encode_atom(buf, &i, "d");
ei_encode_list_header(buf, &i, 1);
ei_encode_atom(buf, &i, "e");
ei_encode_atom(buf, &i, "f");
ei_encode_empty_list(buf, &i);
ध्यान दें

ऐसा लग सकता है कि अग्रिम में तत्वों की संख्या को जाने बिना सूची बनाने का कोई तरीका नहीं है। लेकिन वास्तव में एक तरीका है। ध्यान दें कि सूची [a, b, c] रूप में लिखी जा सकती है [a | [b | [c]]] [a | [b | [c]]] [a | [b | [c]]] [a | [b | [c]]] । इसका उपयोग करते हुए, एक सूची को सहमति के रूप में लिखा जा सकता है।

अग्रिम रूप से बिना किसी जानकारी के सूची को एनकोड करने के लिए:

while (something()) {
    ei_x_encode_list_header(&x, 1);
    ei_x_encode_ulong(&x, i); /* just an example */
}
ei_x_encode_empty_list(&x);

int ei_encode_long(char *buf, int *index, long p) int ei_x_encode_long(ei_x_buff* x, long p)

द्विआधारी प्रारूप में एक लंबे पूर्णांक को एनकोड करता है। यदि कोड 64 बिट्स है, तो फ़ंक्शन ei_encode_long() के समान है।

int ei_encode_longlong(char *buf, int *index, long long p) int ei_x_encode_longlong(ei_x_buff* x, long long p)

बाइनरी प्रारूप में एक जीसीसी long long या दृश्य C ++ __int64 (64-बिट) पूर्णांक को __int64 करता है। यह फ़ंक्शन VxWorks पोर्ट में अनुपलब्ध है।

int ei_encode_map_header(char *buf, int *index, int arity) int ei_x_encode_map_header(ei_x_buff* x, int arity)

एक निर्दिष्ट शीर्षता के साथ, एक मैप हेडर एनकोड करता है। अगले क्रम में arity*2 शब्द एन्कोडेड निम्नलिखित क्रम में एन्कोड किए गए नक्शे की कुंजी और मूल्य होंगे: K1, V1, K2, V2, ..., Kn, Vn

उदाहरण के लिए, मैप को एनकोड करने के लिए #{a => "Apple", b => "Banana"} :

ei_x_encode_map_header(&x, 2);
ei_x_encode_atom(&x, "a");
ei_x_encode_string(&x, "Apple");
ei_x_encode_atom(&x, "b");
ei_x_encode_string(&x, "Banana");

सही ढंग से एन्कोडेड मैप में डुप्लिकेट कुंजियाँ नहीं हो सकती हैं।

int ei_encode_pid(char *buf, int *index, const erlang_pid *p) int ei_x_encode_pid(ei_x_buff* x, const erlang_pid *p)

बाइनरी प्रारूप में एक एरलांग प्रक्रिया पहचानकर्ता (पीआईडी) को एनकोड करता है। पैरामीटर p एक erlang_pid संरचना की ओर erlang_pid करता है (जिसे पहले ei_decode_pid() ) के साथ प्राप्त किया जाना चाहिए।

int ei_encode_port(char *buf, int *index, const erlang_port *p) int ei_x_encode_port(ei_x_buff* x, const erlang_port *p)

बाइनरी प्रारूप में एक एरलांग बंदरगाह को एनकोड करता है। पैरामीटर p एक erlang_port संरचना की ओर erlang_port करता है (जिसे पहले ei_decode_port() ) के साथ प्राप्त किया जाना चाहिए।

int ei_encode_ref(char *buf, int *index, const erlang_ref *p) int ei_x_encode_ref(ei_x_buff* x, const erlang_ref *p)

बाइनरी प्रारूप में एक एरलांग संदर्भ को एनकोड करता है। पैरामीटर p एक erlang_ref संरचना की ओर erlang_ref करता है (जिसे पहले ei_decode_ref() ) के साथ प्राप्त किया जाना चाहिए।

int ei_encode_string(char *buf, int *index, const char *p) int ei_encode_string_len(char *buf, int *index, const char *p, int len) int ei_x_encode_string(ei_x_buff* x, const char *p) int ei_x_encode_string_len(ei_x_buff* x, const char* s, int len) int ei_x_encode_string(ei_x_buff* x, const char *p) int ei_x_encode_string_len(ei_x_buff* x, const char* s, int len)

बाइनरी प्रारूप में एक स्ट्रिंग को एनकोड करता है। (एर्लांग में एक स्ट्रिंग एक सूची है, लेकिन द्विआधारी प्रारूप में एक चरित्र सरणी के रूप में एन्कोडेड है।) स्ट्रिंग को पूर्ण-रहित होना NULL , केवल ei_x_encode_string_len() फ़ंक्शन को छोड़कर।

int ei_encode_term(char *buf, int *index, void *t) int ei_x_encode_term(ei_x_buff* x, void *t)

ETERM से प्राप्त किए गए erl_interface एक ETERM को erl_interface । पैरामीटर t वास्तव में एक ETERM पॉइंटर है। यह फ़ंक्शन ETERM मुक्त नहीं करता है।

int ei_encode_trace(char *buf, int *index, const erlang_trace *p) int ei_x_encode_trace(ei_x_buff* x, const erlang_trace *p)

बाइनरी प्रारूप में एक एरलांग ट्रेस टोकन को एनकोड करता है। पैरामीटर p एक erlang_trace संरचना की ओर erlang_trace करता है (जिसे पहले ei_decode_trace() ) के साथ प्राप्त किया जाना चाहिए।

int ei_encode_tuple_header(char *buf, int *index, int arity) int ei_x_encode_tuple_header(ei_x_buff* x, int arity)

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

उदाहरण के लिए, टपल को एन्कोड करने के लिए {a, {b, {}}} :

ei_encode_tuple_header(buf, &i, 2);
ei_encode_atom(buf, &i, "a");
ei_encode_tuple_header(buf, &i, 2);
ei_encode_atom(buf, &i, "b");
ei_encode_tuple_header(buf, &i, 0);

int ei_encode_ulong(char *buf, int *index, unsigned long p) int ei_x_encode_ulong(ei_x_buff* x, unsigned long p)

बाइनरी प्रारूप में एक अहस्ताक्षरित लंबे पूर्णांक को एनकोड करता है। यदि कोड 64 बिट्स है, तो फ़ंक्शन ei_encode_ulong() के समान है।

int ei_encode_ulonglong(char *buf, int *index, unsigned long long p) int ei_x_encode_ulonglong(ei_x_buff* x, unsigned long long p) int ei_encode_ulonglong(char *buf, int *index, unsigned long long p) int ei_x_encode_ulonglong(ei_x_buff* x, unsigned long long p)

बाइनरी प्रारूप में एक जीसीसी unsigned long long या दृश्य सी ++ unsigned __int64 (64-बिट) पूर्णांक को unsigned __int64 करता है। यह फ़ंक्शन VxWorks पोर्ट में अनुपलब्ध है।

int ei_encode_version(char *buf, int *index) int ei_x_encode_version(ei_x_buff* x)

द्विआधारी प्रारूप के लिए एक संस्करण जादू संख्या को एनकोड करता है। बाइनरी टर्म में पहला टोकन होना चाहिए।

int ei_get_type(const char *buf, const int *index, int *type, int *size)

एन्कोडेड टर्म के आकार में size और प्रकार में रिटर्न। स्ट्रिंग्स और परमाणुओं के लिए, आकार उन वर्णों की संख्या है जिनमें समाप्ति NULL शामिल नहीं NULL । बायनेरिज़ के लिए, size बाइट्स की संख्या है। सूचियों और टुपल्स के लिए, size वस्तु की समानता है। अन्य प्रकारों के लिए, size 0. है। सभी मामलों में, index को अपरिवर्तित छोड़ दिया जाता है।

int ei_print_term(FILE* fp, const char* buf, int* index) int ei_s_print_term(char** s, const char* buf, int* index)

किसी शब्द को, स्पष्ट पाठ में, fp द्वारा निर्दिष्ट फ़ाइल में, या s द्वारा इंगित बफर को प्रिंट करता है। यह Erlang खोल में मुद्रण शब्द से मिलता जुलता है।

ei_s_print_term() , पैरामीटर s को BUFSIZ बाइट्स या NULL पॉइंटर के एक डायनामिक रूप से (Malloc) आवंटित स्ट्रिंग को BUFSIZ । यदि इस परिणाम BUFSIZ वर्णों से अधिक है, तो BUFSIZ को इस फ़ंक्शन द्वारा BUFSIZ किया जा सकता है (और *s अपडेट किया जा सकता है)। लौटाया गया स्ट्रिंग पूर्ण-रहित है।

वापसी मान फ़ाइल या स्ट्रिंग में लिखे गए वर्णों की संख्या है, या -1 यदि buf[index] में वैध शब्द नहीं है। दुर्भाग्य से, fp पर I / O त्रुटियों की जाँच नहीं की गई है।

तर्क index को अपडेट किया गया है, अर्थात, इस फ़ंक्शन को एक डीकोड फ़ंक्शन के रूप में देखा जा सकता है जो एक शब्द को मानव-पठनीय प्रारूप में डिकोड करता है।

void ei_set_compat_rel(release_number)

प्रकार

डिफ़ॉल्ट रूप से, ei लाइब्रेरी केवल ei लाइब्रेरी के रूप में उसी रिलीज से अन्य एर्लांग / ओटीपी घटकों के साथ संगत होने की गारंटी है। उदाहरण के लिए, Erlang / OTP R10 से ei डिफ़ॉल्ट रूप से Erlang / OTP R9 से Erlang एमुलेटर के साथ संगत नहीं है।

ei_set_compat_rel(release_number) कॉल रिलीज़ लाइब्रेरी को रिलीज़ ei_set_compat_rel(release_number) अनुकूलता मोड में release_number release_number की वैध सीमा [7, current release] । इससे पहले रिलीज़ से Erlang / OTP घटकों के साथ संवाद करना संभव हो जाता है।

ध्यान दें

यदि इस फ़ंक्शन को कॉल किया जाता है, तो इसे केवल एक बार कॉल किया जा सकता है और ei लाइब्रेरी में किसी भी अन्य फ़ंक्शन को कॉल करने से पहले कॉल किया जाना चाहिए।

चेतावनी

यदि आप इस सुविधा का लापरवाही से उपयोग करते हैं तो आप मुश्किल में पड़ सकते हैं। हमेशा सुनिश्चित करें कि सभी संचार घटक या तो एक ही एरलंग / ओटीपी रिलीज़ से हैं, या रिलीज़ एक्स और रिलीज़ वाई से हैं जहाँ रिलीज़ वाई से सभी घटक रिलीज़ एक्स की संगतता मोड में हैं।

int ei_skip_term(const char* buf, int* index)

निर्दिष्ट बफर में एक शब्द को छोड़ देता है; पुनरावर्ती सूचियों और टुपल्स के तत्वों को छोड़ देता है, ताकि एक पूर्ण शब्द छोड़ दिया जाए। यह एक एर्लांग शब्द के आकार को प्राप्त करने का एक तरीका है।

buf बफर है।

index बफर में शब्द के ठीक बाद इंगित करने के लिए अद्यतन किया जाता है।

ध्यान दें

यह तब उपयोगी हो सकता है जब आप मनमाने ढंग से शर्तें रखना चाहते हैं: उन्हें छोड़ दें और बाइनरी टर्म डेटा को कुछ बफर में कॉपी करें।

सफलता पर 0 लौटता है, अन्यथा -1

int ei_x_append(ei_x_buff* x, const ei_x_buff* x2) int ei_x_append_buf(ei_x_buff* x, const char* buf, int len)

बफर x के अंत में डेटा को लागू करता है।

int ei_x_format(ei_x_buff* x, const char* fmt, ...) int ei_x_format_wo_ver(ei_x_buff* x, const char *fmt, ... )

एक शब्द को प्रारूप, एक स्ट्रिंग के रूप में, एक बफर को दिया जाता है। Erlang शब्दों के लिए स्प्रिंट की तरह काम करता है। fmt में वैरिएबल से शब्द डालने के लिए ~d जैसे तर्कों के साथ एक प्रारूप स्ट्रिंग है। निम्नलिखित प्रारूप समर्थित हैं (दिए गए C प्रकार के साथ):

~a  An atom, char*
~c  A character, char
~s  A string, char*
~i  An integer, int
~l  A long integer, long int
~u  A unsigned long integer, unsigned long int
~f  A float, float
~d  A double float, double float
~p  An Erlang pid, erlang_pid*

उदाहरण के लिए, कुछ सामान के साथ एक टपल को एनकोड करने के लिए:

ei_x_format("{~a,~i,~d}", "numbers", 12, 3.14159)
encodes the tuple {numbers,12,3.14159}

प्रारंभिक संस्करण बाइट के बिना ei_x_format_wo_ver() एक बफर में प्रारूप।

int ei_x_free(ei_x_buff* x)

एक ei_x_buff बफर का उपयोग करता है। बफर द्वारा उपयोग की जाने वाली मेमोरी ओएस पर वापस आ जाती है।

int ei_x_new(ei_x_buff* x) int ei_x_new_with_version(ei_x_buff* x)

एक नया ei_x_buff बफर आवंटित करता है। पैरामीटर x द्वारा बताए गए संरचना के क्षेत्र में भरा हुआ है, और एक डिफ़ॉल्ट बफर आवंटित किया गया है। ei_x_new_with_version() एक प्रारंभिक संस्करण बाइट भी डालता है, जिसका उपयोग बाइनरी प्रारूप में किया जाता है (ताकि ei_x_encode_version() की आवश्यकता नहीं होगी।)

डिबग जानकारी

जब एमुलेटर आपके द्वारा भेजे जाने वाले शब्दों को प्राप्त नहीं करता है, तो क्या जांचना है, इस पर कुछ सुझाव:

  • संस्करण हैडर से सावधान रहें, उपयुक्त होने पर ei_x_new_with_version() उपयोग करें।
  • Erlang नोड पर वितरण ट्रेसिंग चालू करें।
  • ei_decode_-calls से परिणाम कोड जांचें।

यह भी देखें

erl_eterm