भ्रमित - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

पेरलेम्बेड - अपने सी प्रोग्राम में पर्ल को कैसे एम्बेड करें

वर्णन

प्रस्तावना
क्या आप करना यह चाहते हैं:

उपयोग C से पर्ल?
Perlxstut, perlxs, h2xs, perlguts, और perlapi पढ़ें।

उपयोग a यूनिक्स कार्यक्रम से पर्ल?
पर्लफंक में बैक-कोट्स और "सिस्टम" और "एक्जीक्यूटिव" के बारे में पढ़ें।

उपयोग पर्ल से पर्ल?
Perlfunc में "do" और perlfunc में "eval" और perlfunc में "require" के बारे में पढ़ें और
perlfunc में "उपयोग करें"।

उपयोग C से C?
अपने डिज़ाइन पर पुनर्विचार करें.

उपयोग पर्ल से C?
पढ़ते रहिये...

रोडमैप
· अपने सी प्रोग्राम को संकलित करना

· अपने सी प्रोग्राम में एक पर्ल दुभाषिया जोड़ना

· अपने सी प्रोग्राम से पर्ल सबरूटीन को कॉल करना

· आपके सी प्रोग्राम से पर्ल स्टेटमेंट का मूल्यांकन करना

· आपके सी प्रोग्राम से पर्ल पैटर्न मिलान और प्रतिस्थापन करना

· आपके सी प्रोग्राम से पर्ल स्टैक के साथ खिलवाड़

· लगातार दुभाषिया बनाए रखना

· एकाधिक दुभाषिया उदाहरणों को बनाए रखना

· आपके सी प्रोग्राम से पर्ल मॉड्यूल का उपयोग करना, जो स्वयं सी लाइब्रेरी का उपयोग करते हैं

· Win32 के अंतर्गत पर्ल को एंबेड करना

संकलन तुंहारे C कार्यक्रम
यदि आपको इस दस्तावेज़ में स्क्रिप्ट संकलित करने में परेशानी हो रही है, तो आप अकेले नहीं हैं।
मुख्य नियम: प्रोग्रामों को बिल्कुल उसी तरह संकलित करें जैसे आपका पर्ल संकलित किया गया था।
(चिल्लाने के लिए क्षमा करें।)

साथ ही, पर्ल का उपयोग करने वाले प्रत्येक C प्रोग्राम को इसमें लिंक करना होगा पर्ल पुस्तकालय. आप पूछें, वह क्या है?
पर्ल स्वयं C में लिखा गया है; पर्ल लाइब्रेरी संकलित सी प्रोग्रामों का संग्रह है
जिनका उपयोग आपके पर्ल को निष्पादन योग्य बनाने के लिए किया गया था (/usr/bin/perl या उसके बराबर)। (परिणाम:
आप अपने सी प्रोग्राम से पर्ल का उपयोग तब तक नहीं कर सकते जब तक कि पर्ल को आपकी मशीन पर संकलित नहीं किया गया हो, या
ठीक से इंस्टॉल किया गया है--इसीलिए आपको मशीन से पर्ल एक्ज़ीक्यूटेबल्स को लापरवाही से कॉपी नहीं करना चाहिए
बिना कॉपी किए भी मशीन में डालना lib निर्देशिका।)

जब आप सी से पर्ल का उपयोग करते हैं, तो आपका सी प्रोग्राम आमतौर पर आवंटित, "रन" और डीलीलोकेट करेगा
पर्लइंटरप्रेटर ऑब्जेक्ट, जिसे पर्ल लाइब्रेरी द्वारा परिभाषित किया गया है।

यदि आपकी पर्ल की प्रति इस दस्तावेज़ (संस्करण 5.002 या) को शामिल करने के लिए पर्याप्त नवीनतम है
बाद में), फिर पर्ल लाइब्रेरी (और बाहरी.एच और पर्ल.एच, जिसकी आपको भी आवश्यकता होगी) होगी
ऐसी निर्देशिका में निवास करें जो इस तरह दिखती है:

/usr/local/lib/perl5/your_architecture_here/CORE

या शायद बस

/usr/local/lib/perl5/CORE

या शायद ऐसा कुछ

/usr/opt/perl5/CORE

CORE कहां मिलेगा इसके बारे में संकेत के लिए इस कथन को निष्पादित करें:

पर्ल -एमकॉन्फिग -ई 'प्रिंट $कॉन्फिग{आर्कलिब}'

यहां बताया गया है कि आप अगले भाग में उदाहरण कैसे संकलित करेंगे, "पर्ल दुभाषिया जोड़ना
आपका सी प्रोग्राम", मेरे लिनक्स बॉक्स पर:

% gcc -O2 -Dbool=char -DHAS_BOOL -I/usr/local/include
-I/usr/local/lib/perl5/i586-linux/5.003/CORE
-L/usr/local/lib/perl5/i586-linux/5.003/CORE
-ओ इंटरपी इंटरपी.सी -एलपर्ल -एलएम

(यह सब एक पंक्ति है।) मेरे डीईसी अल्फा पर पुराना 5.003_05 चल रहा है, मंत्र थोड़ा सा है
भिन्न हो:

% cc -O2 -Olimit 2900 -DSTANDARD_C -I/usr/local/include
-I/usr/local/lib/perl5/alpha-dec_osf/5.00305/CORE
-L/usr/local/lib/perl5/alpha-dec_osf/5.00305/CORE -L/usr/स्थानीय/lib
-D__LANGUAGE_C__ -D_NO_PROTO -o interp interp.c -lperl -lm

आप कैसे पता लगा सकते हैं कि क्या जोड़ना है? यह मानते हुए कि आपका पर्ल 5.001 के बाद का है, "पर्ल -V" निष्पादित करें
आदेश दें और "सीसी" और "सीसीफ्लैग" जानकारी पर विशेष ध्यान दें।

आपको उपयुक्त कंपाइलर चुनना होगा (cc, जीसीसी, एट अल.) आपकी मशीन के लिए: "perl
-MConfig -e 'print $Config{cc}'" आपको बताएगा कि क्या उपयोग करना है।

आपको उपयुक्त लाइब्रेरी निर्देशिका भी चुननी होगी (/usr/स्थानीय/lib/...) आपके लिए
मशीन। यदि आपका कंपाइलर शिकायत करता है कि कुछ फ़ंक्शन अपरिभाषित हैं, या यह
पता नहीं चल सका -एलपर्ल, तो आपको "-L" का अनुसरण करते हुए पथ बदलने की आवश्यकता है। अगर यह शिकायत करता है
कि यह नहीं मिल सकता है बाहरी.एच और पर्ल.एच, आपको "-I" का अनुसरण करते हुए पथ बदलना होगा।

आपको अतिरिक्त लाइब्रेरी भी जोड़नी पड़ सकती है. जो लोग? शायद जिनके द्वारा मुद्रित किया गया है

पर्ल -एमकॉन्फिग -ई 'प्रिंट $कॉन्फिग{libs}'

बशर्ते आपकी पर्ल बाइनरी ठीक से कॉन्फ़िगर और इंस्टॉल की गई हो ExtUtils::एम्बेड मॉड्यूल
आपके लिए यह सारी जानकारी निर्धारित करेगा:

% cc -o interp interp.c `perl -MExtUtils::Embed -e ccopts -e ldopts`

अगर ExtUtils::एम्बेड मॉड्यूल आपके पर्ल वितरण का हिस्सा नहीं है, आप इसे पुनः प्राप्त कर सकते हैं
से http://www.perl.com/perl/CPAN/modules/by-module/ExtUtils/ (यदि यह दस्तावेज़ आया
आपके पर्ल वितरण से, तो आप 5.004 या बेहतर चला रहे हैं और यह आपके पास पहले से ही है।)

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

जोड़ना a पर्ल दुभाषिया सेवा मेरे तुंहारे C कार्यक्रम
एक अर्थ में, पर्ल (सी प्रोग्राम) पर्ल (भाषा) को एम्बेड करने का एक अच्छा उदाहरण है
मैं इसके साथ एम्बेडिंग प्रदर्शित करूंगा मिनीपर्लमेन.सी, स्रोत वितरण में शामिल है।
यहाँ इसका घटिया, गैर-पोर्टेबल संस्करण है मिनीपर्लमेन.सी की अनिवार्यता युक्त
एम्बेडिंग:

#शामिल करना /*पर्ल वितरण से*/
#शामिल करना /*पर्ल वितरण से*/

स्थिर पर्लइंटरप्रेटर *my_perl; /*** पर्ल दुभाषिया ***/

int मुख्य(int argc, char **argv, char **env)
{
PERL_SYS_INIT3(&argc,&argv,&env);
my_perl = perl_alloc();
perl_construct(my_perl);
PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
perl_parse(my_perl, NULL, argc, argv, (char **)NULL);
perl_run(my_perl);
perl_destruct(my_perl);
perl_free(my_perl);
PERL_SYS_TERM();
}

ध्यान दें कि हम "env" पॉइंटर का उपयोग नहीं करते हैं। आम तौर पर इसके अंतिम के रूप में "perl_parse" को सौंप दिया जाता है
तर्क, यहां "env" को "NULL" से बदल दिया गया है, जिसका अर्थ है कि वर्तमान परिवेश ऐसा करेगा
इस्तेमाल किया गया।

मैक्रोज़ PERL_SYS_INIT3() और PERL_SYS_TERM() सी का सिस्टम-विशिष्ट ट्यून अप प्रदान करें
पर्ल दुभाषियों को चलाने के लिए आवश्यक रनटाइम वातावरण; उन्हें केवल एक बार बुलाया जाना चाहिए
इसकी परवाह किए बिना कि आप कितने दुभाषिए बनाते हैं या नष्ट कर देते हैं। पुकारना PERL_SYS_INIT3() से पहले
आप अपना पहला दुभाषिया बनाते हैं, और PERL_SYS_TERM() अपने अंतिम को मुक्त करने के बाद
दुभाषिया।

जबसे PERL_SYS_INIT3() "env" को बदल सकते हैं, "env" को एक के रूप में प्रदान करना अधिक उपयुक्त हो सकता है
करने के लिए तर्क perl_parse().

यह भी ध्यान दें कि आप चाहे जो भी तर्क दें perl_parse(), PERL_SYS_INIT3() चाहिए
सी पर लागू किया जाए मुख्य() argc, argv और env और केवल एक बार।

अब इस प्रोग्राम को संकलित करें (मैं इसे कॉल करूंगा)। इंटरपी.सी) एक निष्पादन योग्य में:

% cc -o interp interp.c `perl -MExtUtils::Embed -e ccopts -e ldopts`

सफल संकलन के बाद, आप इसका उपयोग कर सकेंगे इंटरपो बिल्कुल पर्ल की तरह:

% इंटरप
प्रिंट करें "बहुत अच्छा पर्ल\n";
प्रिंट करें "10890 - 9801 है ", 10890 - 9801;

बहुत अच्छा पर्ल
10890 - 9801 1089 है

or

% इंटरप -ई 'प्रिंटफ('%x', 3735928559)'
मृत गाय का मांस

आप अपने सी के बीच में रहते हुए किसी फ़ाइल से पर्ल स्टेटमेंट को पढ़ और निष्पादित भी कर सकते हैं
प्रोग्राम, फ़ाइल नाम डालकर एआरजीवी [1] कॉल करने से पहले perl_run.

कॉलिंग a पर्ल सबरूटीन से तुंहारे C कार्यक्रम
व्यक्तिगत पर्ल सबरूटीन्स को कॉल करने के लिए, आप इनमें से किसी का भी उपयोग कर सकते हैं पुकारना_* कार्यों को प्रलेखित किया गया है
पर्लकॉल. इस उदाहरण में हम "call_argv" का उपयोग करेंगे।

यह नीचे दिखाया गया है, एक प्रोग्राम में जिसे मैं कॉल करूंगा शोटाइम.सी.

#शामिल करना
#शामिल करना

स्थिर पर्लइंटरप्रेटर *my_perl;

int मुख्य(int argc, char **argv, char **env)
{
चार *args[] = {शून्य };
PERL_SYS_INIT3(&argc,&argv,&env);
my_perl = perl_alloc();
perl_construct(my_perl);

perl_parse(my_perl, NULL, argc, argv, NULL);
PL_exit_flags |= PERL_EXIT_DESTRUCT_END;

/*** स्किपिंग perl_run() ***/

call_argv("शोटाइम", G_DISCARD | G_NOARGS, args);

perl_destruct(my_perl);
perl_free(my_perl);
PERL_SYS_TERM();
}

जहां शोटाइम एक पर्ल सबरूटीन है जो कोई तर्क नहीं लेता (यही है)। G_NOARGS) और किसके लिए
जिसे मैं रिटर्न वैल्यू पर ध्यान नहीं दूंगा (वह है G_छोड़ें). वे झंडे, और अन्य, हैं
पर्लकॉल में चर्चा की गई।

मैं परिभाषित करूंगा शोटाइम नामक फ़ाइल में सबरूटीन showtime.pl:

प्रिंट करें "मुझे मुद्रित नहीं किया जाएगा";

उप शोटाइम {
मुद्रण समय;
}

काफी सरल। अब संकलित करें और चलाएँ:

% cc -o शोटाइम showtime.c \
`perl -MExtUtils::Embed -e ccopts -e ldopts`
% शोटाइम शोटाइम.pl
818284590

1 जनवरी 1970 (शुरुआत) के बीच बीते सेकंडों की संख्या ज्ञात करना
यूनिक्स युग), और जिस क्षण मैंने यह वाक्य लिखना शुरू किया।

इस विशेष मामले में हमें कॉल करने की आवश्यकता नहीं है perl_run, जैसे ही हम PL_exit_flag सेट करते हैं
PERL_EXIT_DESTRUCT_END जो perl_destruct में END ब्लॉक निष्पादित करता है।

यदि आप पर्ल सबरूटीन में तर्क पारित करना चाहते हैं, तो आप इसमें स्ट्रिंग जोड़ सकते हैं
"शून्य"-समाप्त "आर्ग्स" सूची को पास कर दिया गया कॉल_argv. अन्य डेटा प्रकारों के लिए, या जांच करने के लिए
मान लौटाएँ, आपको पर्ल स्टैक में हेरफेर करने की आवश्यकता होगी। यह "फिडलिंग" में प्रदर्शित किया गया है
आपके सी प्रोग्राम से पर्ल स्टैक के साथ"।

का मूल्यांकन a पर्ल कथन से तुंहारे C कार्यक्रम
पर्ल, पर्ल कोड के टुकड़ों का मूल्यांकन करने के लिए दो एपीआई फ़ंक्शन प्रदान करता है। ये "eval_sv" में हैं
पेरलापी और पेरलापी में "eval_pv"।

यकीनन, ये एकमात्र रूटीन हैं जिनकी आपको पर्ल कोड के स्निपेट निष्पादित करने के लिए आवश्यकता होगी
आपके C प्रोग्राम के भीतर से। आपका कोड जब तक आप चाहें तब तक हो सकता है; इसमें एकाधिक शामिल हो सकते हैं
कथन; यह perlfunc में "उपयोग", perlfunc में "आवश्यकता" और perlfunc में "करना" नियोजित कर सकता है
बाहरी पर्ल फ़ाइलें शामिल करने के लिए।

eval_pv आइए हम अलग-अलग पर्ल स्ट्रिंग्स का मूल्यांकन करें, और फिर जबरदस्ती के लिए वेरिएबल निकालें
सी प्रकार में. निम्नलिखित कार्यक्रम, स्ट्रिंग.सी, तीन पर्ल स्ट्रिंग्स निष्पादित करता है, एक निकालता है
पहले से "int", दूसरे से "फ्लोट", और तीसरे से "char*"।

#शामिल करना
#शामिल करना

स्थिर पर्लइंटरप्रेटर *my_perl;

मुख्य (int argc, char **argv, char **env)
{
चार *एम्बेडिंग[] = { "", "-ई", "0" };

PERL_SYS_INIT3(&argc,&argv,&env);
my_perl = perl_alloc();
perl_construct(my_perl);

perl_parse(my_perl, NULL, 3, एम्बेडिंग, NULL);
PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
perl_run(my_perl);

/** $a को एक पूर्णांक मानें **/
eval_pv("$a = 3; $a **= 2", TRUE);
printf('a = %d\n', SvIV(get_sv('a', 0)));

/** $a को एक फ्लोट के रूप में मानें **/
eval_pv("$a = 3.14; $a **= 2", TRUE);
printf('a = %f\n', SvNV(get_sv('a', 0)));

/** $a को एक स्ट्रिंग के रूप में मानें **/
eval_pv(
"$a = 'rekcaH lreP rehtonA tsuJ'; $a = उलटा($a);", TRUE);
printf("a = %s\n", SvPV_nolen(get_sv("a", 0)));

perl_destruct(my_perl);
perl_free(my_perl);
PERL_SYS_TERM();
}

उन सभी अजीब कार्यों के साथ sv उनके नाम पर्ल स्केलर को C में बदलने में मदद करते हैं
प्रकार. उनका वर्णन पर्लगुट्स और पर्लपी में किया गया है।

यदि आप संकलित करते हैं और चलाते हैं स्ट्रिंग.सी, आप उपयोग के परिणाम देखेंगे एसवीआईवी() एक बनाने के लिए
"इंट", एसवीएनवी() एक "फ्लोट" बनाने के लिए, और एसवीपीवी () एक स्ट्रिंग बनाने के लिए:

एक = 9
एक = 9.859600
ए = बस एक और पर्ल हैकर

उपरोक्त उदाहरण में, हमने गणना को अस्थायी रूप से संग्रहीत करने के लिए एक वैश्विक चर बनाया है
हमारी मूल्यांकित अभिव्यक्ति का मूल्य। यह संभव भी है और अधिकांश मामलों में यह एक बेहतर रणनीति भी है
से वापसी मूल्य प्राप्त करने के लिए eval_pv() बजाय। उदाहरण:

...
एसवी * वैल = eval_pv ("रिवर्स 'rekcaH lreP rehtonA tsuJ'", TRUE);
प्रिंटफ ("%s\n", SvPV_nolen(val));
...

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

प्रदर्शन पर्ल पैटर्न मैच और प्रतिस्थापन से तुंहारे C कार्यक्रम
RSI eval_sv() फ़ंक्शन हमें पर्ल कोड की स्ट्रिंग्स का मूल्यांकन करने देता है, ताकि हम कुछ को परिभाषित कर सकें
फ़ंक्शन जो इसका उपयोग मिलान और प्रतिस्थापन में "विशेषज्ञता" के लिए करते हैं: मिलान(), विकल्प(),
और मिलान().

I32 मैच (एसवी *स्ट्रिंग, चार *पैटर्न);

एक स्ट्रिंग और एक पैटर्न दिया गया है (उदाहरण के लिए, "m/clasp/" या "/\b\w*\b/", जो आपके C प्रोग्राम में है
"/\\b\\w*\\b/") के रूप में प्रकट हो सकता है, मिलान() यदि स्ट्रिंग पैटर्न से मेल खाती है तो 1 लौटाता है और 0 लौटाता है
अन्यथा।

पूर्णांक स्थानापन्न (एसवी **स्ट्रिंग, चार *पैटर्न);

एक "एसवी" और एक "=~" ऑपरेशन के लिए एक सूचक दिया गया है (उदाहरण के लिए, "एस/बॉब/रॉबर्ट/जी" या
"tr[AZ][az]"), विकल्प() के अनुसार "एसवी" के भीतर स्ट्रिंग को संशोधित करता है
ऑपरेशन, किए गए प्रतिस्थापनों की संख्या लौटाता है।

SSize_t मिलान (एसवी *स्ट्रिंग, चार *पैटर्न, एवी **मिलान);

एक "एसवी", एक पैटर्न, और एक खाली "एवी" के लिए एक सूचक दिया गया है। मिलान() "$स्ट्रिंग =~" का मूल्यांकन करता है
$पैटर्न" एक सूची संदर्भ में, और भरता है मैच सरणी तत्वों के साथ, वापस लौटना
पाए गए मिलानों की संख्या.

यहाँ एक नमूना कार्यक्रम है, मैच.सी, जो तीनों का उपयोग करता है (लंबी लाइनें यहां लपेटी गई हैं):

#शामिल करना
#शामिल करना

स्थिर पर्लइंटरप्रेटर *my_perl;

/** my_eval_sv(कोड, error_check)
** कुछ-कुछ eval_sv() जैसा,
** लेकिन हम रिटर्न वैल्यू को स्टैक से हटा देते हैं
** /
SV* my_eval_sv(SV *sv, I32 croak_on_error)
{
डीएसपी;
एसवी* रेटवल;

पुशमार्क (एसपी);
eval_sv(sv, G_SCALAR);

स्पेन;
रेटवल = पीओपी;
वापस रखो;

यदि (croak_on_error && SvTRUE(ERRSV))
क्रोक(SvPVx_nolen(ERRSV));

वापसी पुनर्प्राप्ति;
}

/** मिलान (स्ट्रिंग, पैटर्न)
**
** अदिश संदर्भ में मिलान के लिए उपयोग किया जाता है।
**
** यदि मैच सफल रहा तो 1 लौटाता है; 0 अन्यथा.
** /

I32 मैच (एसवी *स्ट्रिंग, चार *पैटर्न)
{
एसवी *कमांड = न्यूएसवी(0), *रिटवल;

sv_setpvf(कमांड, "मेरी $स्ट्रिंग = '%s'; $स्ट्रिंग =~ %s",
SvPV_nolen(स्ट्रिंग), पैटर्न);

रेटवल = my_eval_sv(कमांड, TRUE);
SvREFCNT_dec(कमांड);

वापसी SvIV(रिटवल);
}

/** स्थानापन्न(स्ट्रिंग, पैटर्न)
**
** =~ संचालन के लिए उपयोग किया जाता है
** उनके बाएँ हाथ को संशोधित करें (s /// और tr ///)
**
** सफल मैचों की संख्या लौटाता है, और
** यदि कोई इनपुट स्ट्रिंग हो तो उसे संशोधित करता है।
** /

I32 स्थानापन्न (एसवी **स्ट्रिंग, चार *पैटर्न)
{
एसवी *कमांड = न्यूएसवी(0), *रिटवल;

sv_setpvf(कमांड, "$स्ट्रिंग = '%s'; ($स्ट्रिंग =~ %s)",
SvPV_nolen(*string), पैटर्न);

रेटवल = my_eval_sv(कमांड, TRUE);
SvREFCNT_dec(कमांड);

*स्ट्रिंग = get_sv("स्ट्रिंग", 0);
वापसी SvIV(रिटवल);
}

/** मिलान (स्ट्रिंग, पैटर्न, मिलान)
**
** सूची संदर्भ में मिलान के लिए उपयोग किया जाता है।
**
** मिलानों की संख्या लौटाता है,
** और मेल खाने वाले सबस्ट्रिंग के साथ ** मिलान भरता है
** /

SSize_t मिलान (एसवी *स्ट्रिंग, चार *पैटर्न, एवी **मैच_लिस्ट)
{
एसवी *कमांड = न्यूएसवी; (0)
SSize_t num_matches;

sv_setpvf(कमांड, "मेरी $स्ट्रिंग = '%s'; @array = ($स्ट्रिंग =~ %s)",
SvPV_nolen(स्ट्रिंग), पैटर्न);

my_eval_sv(कमांड, सत्य);
SvREFCNT_dec(कमांड);

*मैच_लिस्ट = get_av('सरणी', 0);
num_matches = av_top_index(*match_list) + 1;

वापसी num_matches;
}

मुख्य (int argc, char **argv, char **env)
{
चार *एम्बेडिंग[] = { "", "-ई", "0" };
एवी *मैच_लिस्ट;
I32 num_matches, i;
एसवी *पाठ;

PERL_SYS_INIT3(&argc,&argv,&env);
my_perl = perl_alloc();
perl_construct(my_perl);
perl_parse(my_perl, NULL, 3, एम्बेडिंग, NULL);
PL_exit_flags |= PERL_EXIT_DESTRUCT_END;

पाठ = न्यूएसवी; (0)
sv_setpv(पाठ, "जब वह एक सुविधा स्टोर पर होता है और "
"बिल 76 सेंट जैसी कुछ राशि का आता है, मेनार्ड है"
"यह जानते हुए कि उसे कुछ करना चाहिए, कुछ"
"इससे वह एक चौथाई वापस पाने में सक्षम हो जाएगा, लेकिन उसके पास है"
"पता नहीं *क्या*। वह अपनी लाल निचोड़ को टटोलता है"
"पर्स बदलें और लड़के को तीन अतिरिक्त पैसे दें"
"उसका डॉलर, उम्मीद है कि शायद उसकी किस्मत सही हो जाए"
"राशि। लड़का उसे अपने दो पैसे वापस देता है"
"और फिर बड़ा चमकदार क्वार्टर जो उसका पुरस्कार है।"
"-रिच");

यदि (मिलान(टेक्स्ट, "एम/क्वार्टर/")) /** क्या टेक्स्ट में 'क्वार्टर' शामिल है? **/
प्रिंटफ ("मिलान: पाठ में 'क्वार्टर' शब्द है।\n\n");
अन्य
प्रिंटफ ("मिलान: टेक्स्ट में 'क्वार्टर' शब्द नहीं है।\n\n");

यदि (मिलान(पाठ, "एम/आठवां/")) /** क्या पाठ में 'आठवां' है? **/
प्रिंटफ ("मिलान: पाठ में 'आठवां' शब्द है।\n\n");
अन्य
प्रिंटफ ("मिलान: पाठ में 'आठवां' शब्द नहीं है।\n\n");

/** /wi../ की सभी घटनाओं का मिलान करें **/
num_matches = मिलान(पाठ, "m/(wi..)/g", &match_list);
प्रिंटफ ("मिलान: m/(wi..)/g %d मिलान मिला...\n", num_matches);

(i = 0; i < num_matches; i++) के लिए
प्रिंटफ ("मिलान: %s\n",
SvPV_nolen(*av_fetch(match_list, i, FALSE)));
प्रिंटफ़('\n');

/**पाठ से सभी स्वर हटा दें**/
num_matches = स्थानापन्न(&text, "s/[aeiou]//gi");
यदि (num_matches) {
प्रिंटफ("विकल्प: s/[aeiou]//gi...%lu प्रतिस्थापन किया गया।\n",
(अहस्ताक्षरित लंबा)num_matches);
प्रिंटफ ("अब पाठ है: %s\n\n", SvPV_nolen(पाठ));
}

/** प्रतिस्थापन का प्रयास करें **/
यदि (!विकल्प(&text, "s/Perl/C/")) {
प्रिंटफ ("विकल्प: s/Perl/C...कोई प्रतिस्थापन नहीं किया गया।\n\n");
}

SvREFCNT_dec(पाठ);
PL_perl_destruct_level = 1;
perl_destruct(my_perl);
perl_free(my_perl);
PERL_SYS_TERM();
}

जो आउटपुट उत्पन्न करता है (फिर से, यहां लंबी लाइनें लपेटी गई हैं)

मिलान: पाठ में 'क्वार्टर' शब्द है।

मिलान: पाठ में 'आठवां' शब्द नहीं है।

मिलान: m/(wi..)/g 2 मिलान मिले...
मैच: होगा
के साथ मेल

स्थानापन्न: s/[aeiou]//gi...139 प्रतिस्थापन किए गए।
अब पाठ है: डब्लूएचएन एचएसटी सीएनवीएनसी एसटी एनडी वें बीएलएल सीएमएस टी एसएम एमएनटी एलके 76 सीएनटी,
Mynrd s wr tht thr s smthng h *shld* d, smthng tht wll nbl hm t gt
bck qrtr, bt h hs nd *wht*। एच एफएमबीएल थ्रू एचएस आरडी एसक्यूजी सीएनजीपीआर एनडी
gvs th बाय thr xtr pnns wth HS dllr, hpng tht h mght lck nt th crrct
mnt. वें द्वारा gvs एचएम bck tw f एचएस wn pnns nd thn th bg shny qrtr tht s
एचएस पीआरजेड. -आरसीएचएच

स्थानापन्न: s/Perl/C...कोई प्रतिस्थापन नहीं किया गया।

निरर्थक साथ में la पर्ल धुआँरा से तुंहारे C कार्यक्रम
स्टैक को समझाने की कोशिश करते समय, अधिकांश कंप्यूटर विज्ञान पाठ्यपुस्तकें कुछ न कुछ बुदबुदाती हैं
कैफेटेरिया प्लेटों के स्प्रिंग-लोडेड कॉलम: आखिरी चीज जिसे आपने स्टैक पर धकेला है
पहली बात तो यह है कि आप बाहर निकलें। यह हमारे उद्देश्यों के लिए होगा: आपका सी प्रोग्राम कुछ को आगे बढ़ाएगा
"पर्ल स्टैक" पर तर्क, कुछ जादू होने पर अपनी आँखें बंद कर लें, और फिर पॉप करें
परिणाम--आपके पर्ल सबरूटीन का रिटर्न मान--स्टैक से बाहर।

सबसे पहले आपको यह जानना होगा कि C प्रकार और पर्ल प्रकार के बीच कैसे कनवर्ट किया जाए newSViv()
और sv_setnv() और नयाएवी() और उनके सभी दोस्त. उनका वर्णन पर्लगट्स और में किया गया है
perlapi.

फिर आपको यह जानना होगा कि पर्ल स्टैक में हेरफेर कैसे करें। इसका वर्णन पर्लकॉल में किया गया है।

एक बार जब आप उन्हें समझ लेते हैं, तो पर्ल को सी में एम्बेड करना आसान हो जाता है।

क्योंकि C में पूर्णांक घातांक के लिए कोई अंतर्निहित फ़ंक्शन नहीं है, आइए पर्ल बनाएं **
ऑपरेटर इसके लिए उपलब्ध है (यह जितना लगता है उससे कम उपयोगी है, क्योंकि पर्ल लागू करता है **
सी के साथ पाउ () समारोह)। सबसे पहले मैं एक स्टब एक्सपोनेंटिएशन फ़ंक्शन बनाऊंगा पावर.पीएल:

सब एक्सपो {
मेरा ($a, $b) = @_;
वापसी $a ** $b;
}

अब मैं एक C प्रोग्राम बनाऊंगा, पॉवर.सी, एक फ़ंक्शन के साथ पर्लपावर() जिसमें सब कुछ शामिल है
दो तर्कों को आगे बढ़ाने के लिए जरूरी है एक्सपो() और रिटर्न वैल्यू पॉप आउट करने के लिए।
गहरी साँस लेना...

#शामिल करना
#शामिल करना

स्थिर पर्लइंटरप्रेटर *my_perl;

स्थिर शून्य
पर्लपावर(int a, int b)
{
डीएसपी; /* स्टैक पॉइंटर प्रारंभ करें */
प्रवेश करना; /*यहाँ के बाद बनाई गई हर चीज़*/
SAVETMPS; /* ...एक अस्थायी चर है. */
पुशमार्क (एसपी); /* स्टैक पॉइंटर याद रखें */
XPUSHs(sv_2mortal(newSViv(a))); /* आधार को स्टैक पर धकेलें */
XPUSHs(sv_2mortal(newSViv(b))); /* घातांक को स्टैक पर धकेलें */
पहली अवस्था में लाना; /* स्थानीय स्टैक पॉइंटर को वैश्विक बनाएं */
call_pv('एक्सपो', G_SCALAR); /* फ़ंक्शन को कॉल करें */
स्पैगैन; /* स्टैक पॉइंटर ताज़ा करें */
/* स्टैक से रिटर्न वैल्यू पॉप करें */
प्रिंटफ़ ("%d से %dth पावर %d है.\n", a, b, POPi);
वापस रखो;
फ्रीटीएमपीएस; /* वह वापसी मान मुफ़्त है */
छुट्टी; /* ...और XPUSHed "नश्वर" तर्क।*/
}

पूर्णांक मुख्य (int argc, char **argv, char **env)
{
चार *my_argv[] = { "", "power.pl" };

PERL_SYS_INIT3(&argc,&argv,&env);
my_perl = perl_alloc();
perl_construct(my_perl);

perl_parse(my_perl, NULL, 2, my_argv, (char **)NULL);
PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
perl_run(my_perl);

पर्लपावर(3); /*** गणना 4 ** 3 ***/

perl_destruct(my_perl);
perl_free(my_perl);
PERL_SYS_TERM();
}

संकलित करें और चलाएं:

% cc -o पॉवर पॉवर.c `perl -MExtUtils::Embed -e ccopts -e ldopts`

% शक्ति
3 से 4थी घात 81 है।

को बनाए रखने के a दृढ़ दुभाषिया
इंटरैक्टिव और/या संभावित रूप से लंबे समय तक चलने वाले एप्लिकेशन विकसित करते समय, यह एक अच्छा विचार है
एक नया आवंटन और निर्माण करने के बजाय एक सतत दुभाषिया बनाए रखना
दुभाषिया कई बार। मुख्य कारण गति है: चूंकि पर्ल केवल लोड किया जाएगा
एक बार स्मृति में.

हालाँकि, आपको a का उपयोग करते समय नेमस्पेस और वेरिएबल स्कोपिंग के साथ अधिक सतर्क रहना होगा
लगातार दुभाषिया. पिछले उदाहरणों में हम वैश्विक चर का उपयोग कर रहे हैं
डिफ़ॉल्ट पैकेज "मुख्य"। हमें ठीक-ठीक पता था कि कौन सा कोड चलाया जाएगा, और मान लिया कि हम ऐसा कर सकते हैं
परिवर्तनशील टकरावों और अपमानजनक प्रतीक तालिका वृद्धि से बचें।

मान लीजिए कि आपका एप्लिकेशन एक सर्वर है जो कभी-कभी कुछ से पर्ल कोड चलाएगा
मनमानी फ़ाइल. आपके सर्वर के पास यह जानने का कोई तरीका नहीं है कि वह कौन सा कोड चलाने जा रहा है। बहुत
खतरनाक।

यदि फ़ाइल को "perl_parse()" द्वारा खींचा जाता है, तो एक नवनिर्मित दुभाषिया में संकलित किया जाता है,
और बाद में "perl_destruct()" से साफ़ कर दिया जाता है, आप अधिकांश से सुरक्षित हो जाते हैं
नामस्थान संबंधी परेशानियाँ.

इस परिदृश्य में नेमस्पेस टकराव से बचने का एक तरीका फ़ाइल नाम का अनुवाद करना है
गारंटीकृत-अद्वितीय पैकेज नाम, और फिर "eval" का उपयोग करके उस पैकेज में कोड संकलित करें
पर्लफंक में. नीचे दिए गए उदाहरण में, प्रत्येक फ़ाइल केवल एक बार संकलित की जाएगी। या
एप्लिकेशन फ़ाइल के समाप्त होने के बाद उससे संबद्ध प्रतीक तालिका को साफ़ करना चुन सकता है
अब जरूरत नहीं। पेरलापी में "call_argv" का उपयोग करके, हम सबरूटीन को कॉल करेंगे
"एम्बेड::पर्सिस्टेंट::eval_file" जो फ़ाइल "persistent.pl" में रहता है और पास करता है
तर्क के रूप में फ़ाइल नाम और बूलियन क्लीनअप/कैश फ़्लैग।

ध्यान दें कि यह प्रक्रिया उपयोग की जाने वाली प्रत्येक फ़ाइल के लिए बढ़ती रहेगी। इसके अलावा,
"ऑटोलोड" वाले सबरूटीन्स और अन्य स्थितियाँ हो सकती हैं जो पर्ल के प्रतीक का कारण बनती हैं
बढ़ने के लिए टेबल. हो सकता है कि आप कुछ तर्क जोड़ना चाहें जो प्रक्रिया के आकार पर नज़र रखता हो, या
यह सुनिश्चित करने के लिए कि मेमोरी की खपत हो, अनुरोधों की एक निश्चित संख्या के बाद स्वयं को पुनरारंभ करता है
न्यूनतम किया गया। आप जब भी perlfunc में अपने वेरिएबल्स को "my" के साथ स्कोप करना चाहेंगे
संभव.

पैकेज एम्बेड::स्थायी;
#persistent.pl

सख्त उपयोग करें;
हमारा %कैश;
प्रतीक qw(delete_package) का उपयोग करें;

उप वैध_पैकेज_नाम {
मेरी($स्ट्रिंग) = @_;
$string =~ s/([^A-Za-z0-9\/])/sprintf("_%2x",unpack("C",$1))/उदाहरण;
# केवल अंक से शुरू होने वाले शब्दों के लिए दूसरा पास
$string =~ s|/(\d)|sprintf("/_%2x",unpack("C",$1))|उदाहरण;

# इसे वास्तविक पैकेज नाम के रूप में तैयार करें
$string =~ s|/|::|g;
वापसी "एम्बेड"। $स्ट्रिंग;
}

उप eval_file {
मेरा($फ़ाइल नाम, $हटाएं) = @_;
मेरा $पैकेज = वैध_पैकेज_नाम($फ़ाइलनाम);
मेरा $mtime = -M $फ़ाइलनाम;
यदि(परिभाषित $कैश{$पैकेज}{mtime}
&&
$कैश{$पैकेज}{mtime} <= $mtime)
{
# हमने इस सबरूटीन को पहले ही संकलित कर लिया है,
# इसे डिस्क पर अपडेट नहीं किया गया है, करने को कुछ नहीं बचा है
प्रिंट STDERR "पहले से ही संकलित $package->हैंडलर\n";
}
और {
स्थानीय *एफएच;
FH, $फ़ाइलनाम खोलें या "ओपन '$फ़ाइलनाम' $!" खोलें;
स्थानीय($/) = अपरिभाषित;
मेरा $sub= ;
एफएच बंद करें;

#कोड को हमारे अनूठे पैकेज के अंदर एक सबरूटीन में लपेटें
मेरा $eval = qq{पैकेज $पैकेज; उप हैंडलर {$उप; }};
{
# इस ब्लॉक के भीतर हमारे वेरिएबल छुपाएं
मेरा($फ़ाइल नाम,$mtime,$पैकेज,$उप);
eval $eval;
}
$@ मरो अगर $@;

इसे #कैश करें जब तक हम हर बार सफाई नहीं कर रहे हों
$कैश{$पैकेज}{mtime} = $mtime जब तक $हटाएं नहीं;
}

eval {$package->हैंडलर;};
$@ मरो अगर $@;

delete_package($package) यदि $delete;

# चाहो तो देख लो
#प्रिंट डेवेल::Symdump->rnew($package)->as_string, $/;
}

1;

__समाप्त__

/* लगातार.c */
#शामिल करना
#शामिल करना

/* 1 = प्रत्येक अनुरोध के बाद फ़ाइल नाम की प्रतीक तालिका साफ़ करें,
0=नहीं
*/
#ifndef DO_CLEAN
#DO_CLEAN 0 को परिभाषित करें
#endif

#बफ़र_आकार 1024 को परिभाषित करें

स्थिर पर्लइंटरप्रेटर *my_perl = NULL;

int
मुख्य(int argc, char **argv, char **env)
{
चार *एम्बेडिंग[] = { "", "persistent.pl" };
चार *args[] = { "", DO_CLEAN, NULL };
चार फ़ाइल नाम[BUFFER_SIZE];
पूर्णांक निकासस्थिति = 0;

PERL_SYS_INIT3(&argc,&argv,&env);
अगर((my_perl = perl_alloc()) == शून्य) {
fprintf(stderr, "कोई स्मृति नहीं!");
निकास; (1)
}
perl_construct(my_perl);

PL_origalen = 1; /* $0 असाइनमेंट को अपडेट न करने दें
प्रॉक्टाइटल या एम्बेडिंग[0] */
एग्जिटस्टैटस = perl_parse(my_perl, NULL, 2, एम्बेडिंग, NULL);
PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
अगर(!exitstatus) {
निकास स्थिति = perl_run(my_perl);

जबकि (प्रिंटफ ("फ़ाइल नाम दर्ज करें:") &&
fgets(फ़ाइल नाम, BUFFER_SIZE, stdin)) {

फ़ाइल नाम[strlen(फ़ाइल नाम)-1] = '\0'; /* पट्टी \n */
/* सबरूटीन को कॉल करें,
इसे फ़ाइल नाम को एक तर्क के रूप में पास करना */
तर्क[0] = फ़ाइल नाम;
call_argv('एम्बेड::पर्सिस्टेंट::eval_file'',
G_त्यागें | G_EVAL, args);

/* चेक $@ */
यदि(SvTRUE(ERRSV))
fprintf(stderr, "eval त्रुटि: %s\n", SvPV_nolen(ERRSV));
}
}

PL_perl_destruct_level = 0;
perl_destruct(my_perl);
perl_free(my_perl);
PERL_SYS_TERM();
निकास(निकासस्थिति);
}

अब संकलित करें:

% cc -o लगातार लगातार.c \
`perl -MExtUtils::Embed -e ccopts -e ldopts`

यहां एक उदाहरण स्क्रिप्ट फ़ाइल है:

#test.pl
मेरी $स्ट्रिंग = "हैलो";
फू($स्ट्रिंग);

उप फू {
प्रिंट करें "फू कहता है: @_\n";
}

अब चलाएं:

% ज़िद्दी
फ़ाइल नाम दर्ज करें: test.pl
फू कहते हैं: नमस्ते
फ़ाइल नाम दर्ज करें: test.pl
पहले से ही संकलित Embed::test_2epl->हैंडलर
फू कहते हैं: नमस्ते
फ़ाइल नाम दर्ज करें: ^C

निष्पादन of अंत ब्लॉक
परंपरागत रूप से END ब्लॉक को perl_run के अंत में निष्पादित किया गया है। इसकी वजह से
उन अनुप्रयोगों के लिए समस्याएँ जो कभी भी perl_run को कॉल नहीं करते। चूंकि पर्ल 5.7.2 आप निर्दिष्ट कर सकते हैं
नया व्यवहार प्राप्त करने के लिए "PL_exit_flags |= PERL_EXIT_DESTRUCT_END"। यह भी सक्षम बनाता है
यदि perl_parse विफल रहता है तो END ब्लॉक चलाना और "perl_destruct" निकास लौटा देगा
मूल्य.

$0 कार्य
जब एक पर्ल स्क्रिप्ट $0 का मान निर्दिष्ट करती है तो पर्ल रनटाइम इस मान को बनाने का प्रयास करेगा
argv द्वारा बताई गई मेमोरी को अपडेट करके "ps" द्वारा रिपोर्ट किए गए प्रोग्राम नाम के रूप में दिखाएं
पास किया perl_parse() और एपीआई फ़ंक्शंस को भी कॉल करना जैसे सेटप्रोक्टाइटल() कहाँ उपलब्ध हैं।
पर्ल को एम्बेड करते समय यह व्यवहार उचित नहीं हो सकता है और इसे अक्षम किया जा सकता है
पहले वेरिएबल "PL_origalen" को मान 1 निर्दिष्ट करना perl_parse() कहा जाता है।

RSI लगातार.सी उदाहरण के लिए ऊपर दिए गए उदाहरण में $0 असाइन किए जाने पर सेगफॉल्ट होने की संभावना है
यदि "PL_origalen = 1;" असाइनमेंट हटा दिया गया है. ऐसा इसलिए क्योंकि पर्ल लिखने का प्रयास करेगा
"एम्बेडिंग[]" स्ट्रिंग्स की केवल पढ़ने योग्य मेमोरी।

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

कार्यक्रम को यह सुनिश्चित करने का ध्यान रखना चाहिए कि ऐसा हो से पहले अगला दुभाषिया है
निर्मित. डिफ़ॉल्ट रूप से, जब पर्ल किसी विशेष विकल्प के साथ नहीं बनाया जाता है, तो वैश्विक
वेरिएबल "PL_perl_destruct_level" को 0 पर सेट किया गया है, क्योंकि आमतौर पर अतिरिक्त सफाई की आवश्यकता नहीं होती है
जब कोई प्रोग्राम अपने पूरे जीवनकाल में केवल एक ही दुभाषिया बनाता है।

"PL_perl_destruct_level" को 1 पर सेट करने से सब कुछ बिल्कुल साफ़ हो जाता है:

जब(1) {
...
/* PL_perl_destruct_level = 1 के साथ यहां वैश्विक चर रीसेट करें */
PL_perl_destruct_level = 1;
perl_construct(my_perl);
...
/* perl_destruct के दौरान _everything_ को साफ और रीसेट करें */
PL_perl_destruct_level = 1;
perl_destruct(my_perl);
perl_free(my_perl);
...
/*चलो इसे फिर से करें! */
}

. perl_destruct() कहा जाता है, दुभाषिया के सिंटैक्स पार्स ट्री और प्रतीक तालिकाएँ हैं
साफ़ कर दिया गया है, और वैश्विक चर रीसेट कर दिए गए हैं। को दूसरा कार्यभार
"PL_perl_destruct_level" की आवश्यकता है क्योंकि perl_construct इसे 0 पर रीसेट करता है।

अब मान लीजिए कि हमारे पास एक ही समय में एक से अधिक दुभाषिया उदाहरण चल रहे हैं। यह है
व्यवहार्य, लेकिन केवल तभी जब आपने कॉन्फिगर विकल्प "-Dusemultiplicity" या विकल्पों का उपयोग किया हो
पर्ल बनाते समय "-Duseithreads -Duseithreads"। डिफ़ॉल्ट रूप से, इनमें से किसी एक को सक्षम करना
कॉन्फ़िगर विकल्प प्रति-दुभाषिया वैश्विक चर "PL_perl_destruct_level" को 1 पर सेट करता है,
ताकि पूरी तरह से सफाई स्वचालित हो और दुभाषिया चर प्रारंभ हो जाएं
सही ढंग से. भले ही आपका एक ही समय में दो या दो से अधिक दुभाषियों को चलाने का इरादा न हो, लेकिन
उन्हें क्रमिक रूप से चलाने के लिए, उपरोक्त उदाहरण की तरह, इसके साथ पर्ल बनाने की अनुशंसा की जाती है
"-Dusemultiplicity" विकल्प अन्यथा कुछ दुभाषिया चर प्रारंभ नहीं किए जा सकते हैं
लगातार रन के बीच सही ढंग से काम करने पर आपका एप्लिकेशन क्रैश हो सकता है।

पर्लक्स में "थ्रेड-अवेयर सिस्टम इंटरफ़ेस" भी देखें।

"-Dusemultiplicity" के बजाय "-Dusethreads -Duseithreads" का उपयोग करना अधिक उपयुक्त है यदि
आप विभिन्न थ्रेड्स में एक साथ कई दुभाषियों को चलाने का इरादा रखते हैं, क्योंकि यह
दुभाषिया के साथ आपके सिस्टम की थ्रेड लाइब्रेरी को जोड़ने के लिए समर्थन सक्षम करता है।

आइए इसे एक बार आज़माकर देखते हैं:

#शामिल करना
#शामिल करना

/* हम दो दुभाषियों को शामिल करने जा रहे हैं */

#परिभाषित करें SAY_HELLO "-e", "प्रिंट qq(हाय, मैं $^X\n हूं)"

int मुख्य(int argc, char **argv, char **env)
{
पर्लइंटरप्रेटर *एक_पर्ल, *दो_पर्ल;
चार *one_args[] = { "one_perl", SAY_HELLO };
चार *two_args[] = { "two_perl", SAY_HELLO };

PERL_SYS_INIT3(&argc,&argv,&env);
one_perl = perl_alloc();
two_perl = perl_alloc();

PERL_SET_CONTEXT(one_perl);
perl_construct(one_perl);
PERL_SET_CONTEXT(two_perl);
perl_construct(two_perl);

PERL_SET_CONTEXT(one_perl);
perl_parse(one_perl, NULL, 3, one_args, (char **)NULL);
PERL_SET_CONTEXT(two_perl);
perl_parse(two_perl, NULL, 3, two_args, (char **)NULL);

PERL_SET_CONTEXT(one_perl);
perl_run(one_perl);
PERL_SET_CONTEXT(two_perl);
perl_run(two_perl);

PERL_SET_CONTEXT(one_perl);
perl_destruct(one_perl);
PERL_SET_CONTEXT(two_perl);
perl_destruct(two_perl);

PERL_SET_CONTEXT(one_perl);
perl_free(one_perl);
PERL_SET_CONTEXT(two_perl);
perl_free(two_perl);
PERL_SYS_TERM();
}

को कॉल नोट करें PERL_SET_CONTEXT(). वैश्विक स्थिति को आरंभ करने के लिए ये आवश्यक हैं
यह ट्रैक करता है कि कौन सा दुभाषिया विशेष प्रक्रिया या थ्रेड पर "वर्तमान" है
हो सकता है कि वह इसे चला रहा हो। यदि आपके पास एक से अधिक दुभाषिया हैं तो इसका हमेशा उपयोग किया जाना चाहिए
और इंटरलीव्ड तरीके से दोनों दुभाषियों पर पर्ल एपीआई कॉल कर रहे हैं।

जब भी किसी थ्रेड द्वारा "इंटरपी" का उपयोग किया जाता है तो PERL_SET_CONTEXT(interp) को भी कॉल किया जाना चाहिए
इसे नहीं बनाया (या तो उपयोग करके)। perl_alloc(), या अधिक गूढ़ पर्ल_क्लोन()).

हमेशा की तरह संकलित करें:

% cc -o बहुलता बहुलता.c \
`perl -MExtUtils::Embed -e ccopts -e ldopts`

इसे चलाओ, इसे चलाओ:

% बहुलता
नमस्ते, मैं one_perl हूं
नमस्ते, मैं two_perl हूँ

का प्रयोग पर्ल मॉड्यूल, कौन कौन से अपने उपयोग C पुस्तकालय, से तुंहारे C कार्यक्रम
यदि आपने उपरोक्त उदाहरणों के साथ खेला है और एक स्क्रिप्ट एम्बेड करने का प्रयास किया है उपयोग()सा पर्ल
मॉड्यूल (जैसे गर्तिका) जो स्वयं C या C++ लाइब्रेरी का उपयोग करता है, संभवतः ऐसा हुआ:

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

क्या गलत?

आपका दुभाषिया स्वयं नहीं जानता कि इन एक्सटेंशनों के साथ कैसे संवाद किया जाए। ए
थोड़ा गोंद मदद करेगा. अब तक आप कॉल करते रहे हैं perl_parse(), इसे शून्य के लिए सौंपना
दूसरा तर्क:

perl_parse(my_perl, NULL, argc, my_argv, NULL);

यहीं पर पर्ल और के बीच प्रारंभिक संपर्क बनाने के लिए ग्लू कोड डाला जा सकता है
लिंक्ड C/C++ रूटीन। आइये कुछ अंशों पर नजर डालते हैं perlmain.c यह देखने के लिए कि पर्ल कैसे करता है
इस:

स्थिर शून्य xs_init (pTHX);

EXTERN_C शून्य बूट_डायनालोडर (pTHX_ CV* cv);
EXTERN_C शून्य बूट_सॉकेट (pTHX_ CV* cv);

EXTERN_C शून्य
xs_init(pTHX)
{
चार *फ़ाइल = __फ़ाइल__;
/* डायनालोडर एक विशेष मामला है */
newXS('DynaLoader::boot_DynaLoader', Boot_DynaLoader, फ़ाइल);
newXS ("सॉकेट::बूटस्ट्रैप", बूट_सॉकेट, फ़ाइल);
}

सीधे शब्दों में कहें: आपके पर्ल निष्पादन योग्य से जुड़े प्रत्येक एक्सटेंशन के लिए (इसके दौरान निर्धारित)।
आपके कंप्यूटर पर प्रारंभिक कॉन्फ़िगरेशन या एक नया एक्सटेंशन जोड़ते समय), एक पर्ल सबरूटीन
एक्सटेंशन की दिनचर्या को शामिल करने के लिए बनाया गया है। आम तौर पर, उस सबरूटीन को नाम दिया जाता है
मॉड्यूल::बूटस्ट्रैप() और जब आप कहते हैं तो आह्वान किया जाता है उपयोग मॉड्यूल. बदले में, यह एक में जुड़ जाता है
एक्सएसयूबी, बूट_मॉड्यूल, जो प्रत्येक एक्सटेंशन के XSUB के लिए एक पर्ल समकक्ष बनाता है।
इस हिस्से के बारे में चिंता मत करो; उस पर छोड़ दो xsubpp और विस्तार लेखक। अपने अगर
एक्सटेंशन को गतिशील रूप से लोड किया जाता है, DynaLoader बनाता है मॉड्यूल::बूटस्ट्रैप() आपके लिए
उड़ना। वास्तव में, यदि आपके पास एक कार्यशील डायनालोडर है तो लिंक करने की शायद ही कोई आवश्यकता होगी
स्थिर रूप से कोई अन्य एक्सटेंशन।

एक बार जब आपके पास यह कोड हो, तो इसे दूसरे तर्क में डालें perl_parse():

perl_parse(my_perl, xs_init, argc, my_argv, NULL);

फिर संकलित करें:

% cc -o interp interp.c `perl -MExtUtils::Embed -e ccopts -e ldopts`

% इंटरप
सॉकेट का उपयोग करें;
SomDynamicalLoadedModule का उपयोग करें;

प्रिंट करें "अब मैं एक्सटेंशन का उपयोग कर सकता हूं!\n"'

ExtUtils::एम्बेड लेखन को स्वचालित भी कर सकता है xs_init गोंद कोड.

% perl -MExtUtils::एम्बेड -e xsinit -- -o perlxsi.c
% cc -c perlxsi.c `perl -MExtUtils::Embed -e ccopts`
% cc -c interp.c `perl -MExtUtils::Embed -e ccopts`
% cc -o interp perlxsi.o interp.o `perl -MExtUtils::Embed -e ldopts`

अधिक जानकारी के लिए perlxs, perlguts और perlapi से परामर्श लें।

का प्रयोग एम्बेडेड पर्ल साथ में POSIX स्थानीय
(इनके बारे में जानकारी के लिए पर्ललोकेल देखें।) जब एक पर्ल दुभाषिया सामान्य रूप से शुरू होता है,
यह सिस्टम को बताता है कि वह सिस्टम के डिफ़ॉल्ट लोकेल का उपयोग करना चाहता है। ऐसा अक्सर होता है, लेकिन नहीं
आवश्यक रूप से, "C" या "POSIX" लोकेल। पर्ल कोड के भीतर "स्थान का उपयोग करें" अनुपस्थित है, यह
अधिकतर का कोई प्रभाव नहीं पड़ता है (लेकिन पेरलोकेल में "स्थान का उपयोग करें" के दायरे में नहीं देखें)।
साथ ही, यदि आप अपने एम्बेडेड पर्ल में जिस लोकेल का उपयोग करना चाहते हैं वह कोई समस्या नहीं है
सिस्टम डिफॉल्ट के समान। हालाँकि, यदि आपने सेटअप किया है और उपयोग करना चाहते हैं तो यह काम नहीं करता है
एक ऐसा स्थान जो सिस्टम डिफ़ॉल्ट नहीं है। पर्ल v5.20 से शुरू करके, आप बता सकते हैं
एम्बेडेड पर्ल दुभाषिया कि लोकेल पहले से ही ठीक से सेट अप है, और ऐसा करना छोड़ दें
इसका अपना सामान्य आरंभीकरण है। यदि पर्यावरण परिवर्तनशील है तो यह स्किप हो जाता है
"PERL_SKIP_LOCALE_INIT" सेट है (भले ही 0 या "" पर सेट हो)। एक पर्ल जिसमें यह क्षमता है
C प्री-प्रोसेसर प्रतीक "HAS_SKIP_LOCALE_INIT" को परिभाषित करेगा। यह उस कोड को अनुमति देता है जो है
एक से अधिक पर्ल संस्करणों के साथ काम करने के लिए जब किसी का सामना किया जाता है तो कुछ प्रकार का वर्कअराउंड किया जाता है
पहले पर्ल.

छुपा रहे है पर्ल_

यदि आप पर्ल सार्वजनिक एपीआई के संक्षिप्त रूपों को पूरी तरह छुपाते हैं, तो -DPERL_NO_SHORT_NAMES जोड़ें
संकलन झंडे के लिए. इसका मतलब यह है कि उदाहरण के लिए लिखने के बजाय

चेतावनी('दीवार पर बीयर की %d बोतलें', बोतलों की गिनती);

आपको स्पष्ट फुल फॉर्म लिखना होगा

Perl_warn(aTHX_ "दीवार पर बीयर की %d बोतलें", बोतलों की गिनती);

(स्पष्टीकरण के लिए perlguts में "पृष्ठभूमि और PERL_IMPLICIT_CONTEXT" देखें)
"aTHX_"। ) सभी प्रकार की बुराइयों से बचने के लिए संक्षिप्त रूपों को छिपाना बहुत उपयोगी है (सी
प्रीप्रोसेसर या अन्यथा) अन्य सॉफ्टवेयर पैकेजों के साथ संघर्ष करता है (पर्ल लगभग 2400 को परिभाषित करता है
इन संक्षिप्त नामों वाले एपीआई, कुछ सौ लेते हैं या छोड़ देते हैं, इसलिए निश्चित रूप से जगह है
टकराव।)

नैतिक

आप कभी-कभी कर सकते हैं लिखना और तेज कोड सी में, लेकिन आप हमेशा कर सकते हैं लिखना कोड और तेज पर्ल में.
क्योंकि आप एक-दूसरे से उपयोग कर सकते हैं, उन्हें अपनी इच्छानुसार संयोजित कर सकते हैं।

onworks.net सेवाओं का उपयोग करके ऑनलाइन perlembed का उपयोग करें