एफएफआई: एक PHP कार्यक्रम में जंग में लेखन

PHP 7.4 में, FFI दिखाई देगा, अर्थात आप सी में पुस्तकालयों को कनेक्ट कर सकते हैं (या, उदाहरण के लिए, रस्ट) सीधे, एक पूरे विस्तार को लिखने और इसकी कई बारीकियों को समझने के बिना।

आइए Rust में कोड लिखने का प्रयास करें, और इसे PHP प्रोग्राम में उपयोग करें

PHP 7.4 में FFI को लागू करने का विचार LuaJIT और पायथन से लिया गया था, अर्थात्: एक पार्सर भाषा में बनाया गया है जो कार्यों, संरचनाओं आदि की घोषणाओं को समझता है। सी भाषा। वास्तव में, आप हेडर फ़ाइल की संपूर्ण सामग्री को वहां खिसका सकते हैं और तुरंत इसका उपयोग शुरू कर सकते हैं।

एक उदाहरण:

<?php //    printf    $ffi = FFI::cdef( "int printf(const char *format, ...);", //     "libc.so.6"); //    //  printf $ffi->printf("Hello %s!\n", "world"); 

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

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

अस्वीकरण: मैं एक सिस्टम प्रोग्रामर नहीं हूं, इसलिए अपने जोखिम पर बाकी का उपयोग करें।

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

एक पुस्तकालय के रूप में एक परियोजना बनाएँ

cargo new hellofromrust --lib

और कार्गो में इंगित करें। यह बताएं कि यह एक गतिशील पुस्तकालय है (dylib)

  …. [lib] name="hellofromrust" crate-type = ["dylib"] …. 

रास्ट पर ही फ़ंक्शन इस तरह दिखता है

 #[no_mangle] pub extern "C" fn addNumbers(x: i32, y: i32) -> i32 { x + y } 

अच्छी तरह से यानी सामान्य कार्य, केवल कुछ जादुई शब्द no_mangle और बाहरी "C" जोड़े जाते हैं

अगला, हम कार्गो फाइल को लिनक्स (लिनक्स के तहत) प्राप्त करने के लिए करते हैं

Php से उपयोग कर सकते हैं:

 <?php $ffi = FFI::cdef("int addNumbers(int x, int y);", './libhellofromrust.so'); print "1+2=" . $ffi->addNumbers(1, 2) . "\n"; // 1+2=3 

संख्याओं को जोड़ना आसान है। फ़ंक्शन मान द्वारा पूर्णांक तर्क लेता है, और एक नया पूर्णांक देता है।

लेकिन क्या होगा अगर आपको स्ट्रिंग्स का उपयोग करने की आवश्यकता है? लेकिन क्या होगा अगर कोई फ़ंक्शन तत्वों के पेड़ के लिए एक लिंक देता है? और फ़ंक्शन हस्ताक्षर में रैस्ट के विशिष्ट निर्माणों का उपयोग कैसे करें?

इन सवालों ने मुझे प्रताड़ित किया, इसलिए मैंने रैस्ट पर अंकगणित के भावों का एक पैराग्राफ लिखा। और मैंने इसे सभी बारीकियों का अध्ययन करने के लिए PHP से उपयोग करने का निर्णय लिया।

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

पार्सर, यदि हम शुद्ध रास्ट भाषा पर विचार करते हैं, तो निम्न कार्य करता है:

" 100500*(2+35)-2*5 " फॉर्म की एक स्ट्रिंग लेता है और अभिव्यक्ति को जोड़ता है। ट्री अभिव्यक्ति में बदल जाता है:

 pub enum Expression { Add(Box<Expression>, Box<Expression>), Subtract(Box<Expression>, Box<Expression>), Multiply(Box<Expression>, Box<Expression>), Divide(Box<Expression>, Box<Expression>), UnaryMinus(Box<Expression>), Value(i64), } 

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

मैंने रस्टर के सीमित ज्ञान के बावजूद बहुत तेजी से पार्सर को लिखा, लेकिन मुझे एफएफआई के साथ खुद को पीड़ा देना पड़ा। यदि C में तार एक चार * प्रकार का सूचक है, अर्थात। वर्णों के एक सरणी के लिए एक सूचक \ 0 में समाप्त होता है, फिर रास्ट में यह एक पूरी तरह से अलग प्रकार है। इसलिए, आपको इनपुट स्ट्रिंग को निम्न प्रकार से & str प्रकार में बदलना होगा:

 CStr::from_ptr(s).to_str() 

CStr पर अधिक

यह सब आधी परेशानी है। वास्तविक समस्या यह है कि C में कोई Rast Enums या सुरक्षित बॉक्स लिंक नहीं हैं। इसलिए, मुझे सी-स्टाइल एक्सप्रेशन ट्री, यानी, के भंडारण के लिए एक अलग एक्सप्रेशन फ़िफी संरचना तैयार करनी थी। संरचना, संघ और सरल संकेत ( ffi.rs ) के माध्यम से।

 #[repr(C)] pub struct ExpressionFfi { expression_type: ExpressionType, data: ExpressionData, } #[repr(u8)] pub enum ExpressionType { Add = 0, Subtract = 1, Multiply = 2, Divide = 3, UnaryMinus = 4, Value = 5, } #[repr(C)] pub union ExpressionData { pair_operands: PairOperands, single_operand: *mut ExpressionFfi, value: i64, } #[derive(Copy, Clone)] #[repr(C)] pub struct PairOperands { left: *mut ExpressionFfi, right: *mut ExpressionFfi, } 

खैर, और इसे बदलने के लिए एक विधि:

 impl Expression { fn convert_to_c(&self) -> *mut ExpressionFfi { let expression_data = match self { Value(value) => ExpressionData { value: *value }, Add(left, right) | Subtract(left, right) | Multiply(left, right) | Divide(left, right) => ExpressionData { pair_operands: PairOperands { left: left.convert_to_c(), right: right.convert_to_c(), }, }, UnaryMinus(operand) => ExpressionData { single_operand: operand.convert_to_c(), }, }; let expression_ffi = match self { Add(_, _) => ExpressionFfi { expression_type: ExpressionType::Add, data: expression_data, }, Subtract(_, _) => ExpressionFfi { expression_type: ExpressionType::Subtract, data: expression_data, }, Multiply(_, _) => ExpressionFfi { expression_type: ExpressionType::Multiply, data: expression_data, }, Divide(_, _) => ExpressionFfi { expression_type: ExpressionType::Multiply, data: expression_data, }, UnaryMinus(_) => ExpressionFfi { expression_type: ExpressionType::UnaryMinus, data: expression_data, }, Value(_) => ExpressionFfi { expression_type: ExpressionType::Value, data: expression_data, }, }; Box::into_raw(Box::new(expression_ffi)) } } 

Box::into_raw Box को कच्चे सूचक में बदल देता है

नतीजतन, फ़ंक्शन जिसे हम PHP में निर्यात करेंगे वह इस तरह दिखता है:

 #[no_mangle] pub extern "C" fn parse_arithmetic(s: *const c_char) -> *mut ExpressionFfi { unsafe { // todo: error handling let rust_string = CStr::from_ptr(s).to_str().unwrap(); parse(rust_string).unwrap().convert_to_c() } } 

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

खैर, यहां हम एक मजबूर असुरक्षित ब्लॉक देखते हैं, इसके बिना, कुछ भी संकलित नहीं होता। दुर्भाग्य से, इस कार्यक्रम में, मेमोरी सुरक्षा के लिए रस्ट कंपाइलर जिम्मेदार नहीं हो सकता है। यह समझने योग्य और स्वाभाविक है। जंग और सी के जंक्शन पर, यह हमेशा रहेगा। हालांकि, अन्य सभी स्थानों में सब कुछ बिल्कुल नियंत्रित और सुरक्षित है।

फुफ, यह सब कुछ संकलित किया जा सकता है। लेकिन वास्तव में एक और अति सूक्ष्म अंतर है: आपको अभी भी हेडर निर्माण लिखने की आवश्यकता है ताकि PHP फ़ंक्शन और प्रकारों के हस्ताक्षर को समझ सके।

सौभाग्य से, रास्ट में एक सुविधाजनक सिबिंडगेन उपकरण है। यह स्वचालित रूप से निर्माणों के लिए रास्ट कोड में खोज करता है जिन्हें बाहरी "सी", रिप्र (सी), आदि लेबल किया जाता है। और हेडर फाइल जनरेट करें

मुझे cbindgen सेटिंग्स के साथ थोड़ा नुकसान उठाना पड़ा, वे इस तरह से निकले ( cbindgen.toml ):

 language = "C" no_includes = true style="tag" [parse] parse_deps = true 

मुझे यकीन नहीं है कि मैं स्पष्ट रूप से सभी बारीकियों को समझता हूं, लेकिन यह काम करता है)

लॉन्च उदाहरण:

 cbindgen . -o target/testffi.h 

परिणाम इस प्रकार होगा:

 enum ExpressionType { Add = 0, Subtract = 1, Multiply = 2, Divide = 3, UnaryMinus = 4, Value = 5, }; typedef uint8_t ExpressionType; struct PairOperands { struct ExpressionFfi *left; struct ExpressionFfi *right; }; union ExpressionData { struct PairOperands pair_operands; struct ExpressionFfi *single_operand; int64_t value; }; struct ExpressionFfi { ExpressionType expression_type; union ExpressionData data; }; struct ExpressionFfi *parse_arithmetic(const char *s); 

तो, हमने एच-फाइल जेनरेट किया, cargo build लाइब्रेरी को संकलित करें और आप हमारे php कोड लिख सकते हैं। कोड केवल प्रदर्शित करता है कि प्रिंटस्टेपेशन पुनरावृत्ति फ़ंक्शन के साथ स्क्रीन पर हमारी रस्ट लाइब्रेरी द्वारा पार्स किया गया है।

 <?php $cdef = \FFI::cdef(file_get_contents("target/testffi.h"), "target/debug/libexpr_parser.so"); $expression = $cdef->parse_arithmetic("-6-(4+5)+(5+5)*(4-4)"); printExpression($expression); class ExpressionKind { const Add = 0; const Subtract = 1; const Multiply = 2; const Divide = 3; const UnaryMinus = 4; const Value = 5; } function printExpression($expression) { switch ($expression->expression_type) { case ExpressionKind::Add: case ExpressionKind::Subtract: case ExpressionKind::Multiply: case ExpressionKind::Divide: $operations = ["+", "-", "*", "/"]; print "("; printExpression($expression->data->pair_operands->left); print $operations[$expression->expression_type]; printExpression($expression->data->pair_operands->right); print ")"; break; case ExpressionKind::UnaryMinus: print "-"; printExpression($expression->data->single_operand); break; case ExpressionKind::Value: print $expression->data->value; break; } } 

खैर, यह तो है, देखने के लिए धन्यवाद।

भाड़ में जाओ "सब कुछ था।" स्मृति को अभी भी साफ़ करने की आवश्यकता है। रैस्ट अपने जादू को रैस्ट कोड के बाहर लागू नहीं कर सकता है।

एक और विनाश फ़ंक्शन जोड़ें

 #[no_mangle] pub extern "C" fn destroy(expression: *mut ExpressionFfi) { unsafe { match (*expression).expression_type { ExpressionType::Add | ExpressionType::Subtract | ExpressionType::Multiply | ExpressionType::Divide => { destroy((*expression).data.pair_operands.right); destroy((*expression).data.pair_operands.left); Box::from_raw(expression); } ExpressionType::UnaryMinus => { destroy((*expression).data.single_operand); Box::from_raw(expression); } ExpressionType::Value => { Box::from_raw(expression); } }; } } 

Box::from_raw(expression); - कच्चे पॉइंटर को बॉक्स प्रकार में परिवर्तित करता है, और चूंकि इस रूपांतरण का परिणाम किसी के द्वारा उपयोग नहीं किया जाता है, जब आप दायरे से बाहर निकलते हैं तो मेमोरी स्वचालित रूप से नष्ट हो जाती है।

हेडर फ़ाइल बनाने और बनाने के लिए मत भूलना।

और php में हम अपने फंक्शन में कॉल जोड़ते हैं

 $cdef->destroy($expression); 

अब बस इतना ही। यदि आप जोड़ना या बताना चाहते हैं कि मैं कहीं गलत था, तो कृपया बेझिझक टिप्पणी करें।

एक पूर्ण उदाहरण के साथ एक रिपॉजिटरी लिंक पर स्थित है: [ https://github.com/anton-okolelov/simple-rust-arithmetic-parser ]

 # build docker-compose build docker-compose run php74 cargo build docker-compose run php74 cbindgen . -o target/testffi.h #run php docker-compose run php74 php testffi.php 

पुनश्च हम जिंक उत्पाद पॉडकास्ट के अगले अंक में इस पर चर्चा करेंगे, इसलिए पॉडकास्ट की सदस्यता सुनिश्चित करें।