दिलचस्प पोस्ट
java.text.ParseException: अप्रभावी तिथि फोनगैप – एंड्रॉइड ऐप के लिए स्प्लैश स्क्रीन __gnu_mcount_nc के साथ समारोह से बाहर निकलने का समय कैप्चर करना उपयोगकर्ता 'रूट @ लोकलहोस्ट' के लिए प्रवेश निषेध (पासवर्ड का उपयोग करते हुए: नहीं) क्या यह सही तरीके से साफ करने के लिए एक टुकड़े का टुकड़ा वापस ढेर जब गहरा नेस्टेड स्टैक छोड़ रहा है? मैजिक $ – रुबी में प्रीफिक्स वैरिएबल; क्या कोई संपूर्ण संदर्भ कहीं है? एएसपी.नेट जेएसओएन वेब सेवाओं को 'डी' में परिणाम क्यों मिलता है? सीएसएस क्षैतिज सूची आइटम सी में एक सरणी में एक पाठ फ़ाइल को पढ़ना PHP में हेडॉक का उपयोग करने का क्या फायदा है? आर और र्वेका का उपयोग करते हुए टर्मडायंट मैट्रिक्स में एकल शब्द के बजाय बड़ेम LinearLayout के साथ स्क्रीन के नीचे बटन रखो? अवैध जावा रिगेक्स अवैध तरीके से फेंकना एज़ुर वेब साइट और एक नीला वेब रोल के बीच अंतर क्या है सी # में किसी पाठ फ़ाइल की एक विशिष्ट पंक्ति को संपादित करें

सी से कार्य चलें

मैं सी प्रोग्राम (जैसे, एक कर्नेल मॉड्यूल या कुछ और) के साथ इंटर इंटरफेस में लिखा गया एक स्थिर ऑब्जेक्ट बनाने की कोशिश कर रहा हूं।

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

जो मुझे मिला वह यहां है:

सी और गो के बीच कॉलबैक के बारे में ब्लॉग पोस्ट करें

Cgo दस्तावेज़ीकरण

गोलांग मेलिंग लिस्ट पोस्ट

क्या किसी के पास इसका अनुभव है? संक्षेप में, मैं पा में पूरी तरह से लिखा गया एक पीएएम मॉड्यूल बनाने का प्रयास कर रहा हूं।

वेब के समाधान से एकत्रित समाधान "सी से कार्य चलें"

आप गो कोड को सी से कॉल कर सकते हैं। हालांकि यह भ्रामक प्रस्ताव है।

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

package foo // extern int goCallbackHandler(int, int); // // static int doAdd(int a, int b) { // return goCallbackHandler(a, b); // } import "C" //export goCallbackHandler func goCallbackHandler(a, b C.int) C.int { return a + b } // This is the public function, callable from outside this package. // It forwards the parameters to C.doAdd(), which in turn forwards // them back to goCallbackHandler(). This one performs the addition // and yields the result. func MyAdd(a, b int) int { return int( C.doAdd( C.int(a), C.int(b)) ) } 

जिस आदेश में सब कुछ कहा जाता है वह निम्न प्रकार है:

 foo.MyAdd(a, b) -> C.doAdd(a, b) -> C.goCallbackHandler(a, b) -> foo.goCallbackHandler(a, b) 

यहां याद रखने की कुंजी यह है कि कॉलबैक फ़ंक्शन को Go side पर //export टिप्पणी के साथ और सी बाजू पर extern रूप में चिह्नित किया जाना चाहिए। इसका मतलब यह है कि जिस भी कॉलबैक का आप उपयोग करना चाहते हैं, उसे आपके पैकेज में परिभाषित किया जाना चाहिए।

अपने पैकेज के उपयोगकर्ता को कस्टम कॉलबैक फ़ंक्शन की आपूर्ति करने के लिए, हम उपर्युक्त के समान सटीक दृष्टिकोण का उपयोग करते हैं, लेकिन हम उपयोगकर्ता के कस्टम हैंडलर (जो सिर्फ एक नियमित गो फ़ंक्शन है) को एक पैरामीटर के रूप में प्रदान करते हैं जो सी void* रूप में पक्ष void* यह तब हमारे पैकेज में कॉलबैकहैंडल द्वारा प्राप्त किया जाता है और कहा जाता है।

आइए एक और अधिक उन्नत उदाहरण का उपयोग करें I वर्तमान में साथ काम कर रहा हूँ इस मामले में, हमारे पास C फ़ंक्शन है जो एक बहुत ही भारी कार्य करता है: यह एक USB डिवाइस से फ़ाइलों की एक सूची पढ़ता है। इसमें कुछ समय लग सकता है, इसलिए हम चाहते हैं कि हमारे ऐप को अपनी प्रगति के बारे में सूचित किया जाए। हम ऐसा फ़ंक्शन पॉइंटर में पास करके कर सकते हैं जिसे हमने हमारे कार्यक्रम में परिभाषित किया है। यह केवल उपयोगकर्ता को कुछ प्रगति की जानकारी प्रदर्शित करता है, जब भी इसे कहा जाता है चूंकि इसकी एक सुप्रसिद्ध हस्ताक्षर है, इसलिए हम उसे अपना स्वयं का प्रकार निर्दिष्ट कर सकते हैं:

 type ProgressHandler func(current, total uint64, userdata interface{}) int 

यह हेन्डलर कुछ प्रगति की जानकारी लेता है (वर्तमान फाइलों की संख्या और फ़ाइलों की कुल संख्या) एक इंटरफ़ेस {} मान के साथ जो उस उपयोगकर्ता को इसे पकड़ने के लिए कुछ भी पकड़ सकता है

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

 package foo // #include <somelib.h> // extern int goProgressCB(uint64_t current, uint64_t total, void* userdata); // // static int goGetFiles(some_t* handle, void* userdata) { // return somelib_get_files(handle, goProgressCB, userdata); // } import "C" import "unsafe" 

नोट करें कि goGetFiles() फ़ंक्शन पैरामीटर के रूप में कॉलबैक के लिए कोई फ़ंक्शन पॉइंटर्स नहीं लेता है इसके बजाय, हमारे उपयोगकर्ता द्वारा प्रदान किए गए कॉलबैक एक कस्टम स्ट्रक्चर में पैक किया गया है जो कि हेन्डलर और उपयोगकर्ता के उपयोगकर्ताडाटा मान दोनों को धारण करता है। हम इसे goGetFiles() में userdata पैरामीटर के रूप में पास करते हैं।

 // This defines the signature of our user's progress handler, type ProgressHandler func(current, total uint64, userdata interface{}) int // This is an internal type which will pack the users callback function and userdata. // It is an instance of this type that we will actually be sending to the C code. type progressRequest struct { f ProgressHandler // The user's function pointer d interface{} // The user's userdata. } //export goProgressCB func goProgressCB(current, total C.uint64_t, userdata unsafe.Pointer) C.int { // This is the function called from the C world by our expensive // C.somelib_get_files() function. The userdata value contains an instance // of *progressRequest, We unpack it and use it's values to call the // actual function that our user supplied. req := (*progressRequest)(userdata) // Call req.f with our parameters and the user's own userdata value. return C.int( req.f( uint64(current), uint64(total), req.d ) ) } // This is our public function, which is called by the user and // takes a handle to something our C lib needs, a function pointer // and optionally some user defined data structure. Whatever it may be. func GetFiles(h *Handle, pf ProgressFunc, userdata interface{}) int { // Instead of calling the external C library directly, we call our C wrapper. // We pass it the handle and an instance of progressRequest. req := unsafe.Pointer(&progressequest{ pf, userdata }) return int(C.goGetFiles( (*C.some_t)(h), req )) } 

यही हमारे सी बाइंडिंग के लिए है उपयोगकर्ता का कोड अब बहुत सीधे आगे है:

 package main import ( "foo" "fmt" ) func main() { handle := SomeInitStuff() // We call GetFiles. Pass it our progress handler and some // arbitrary userdata (could just as well be nil). ret := foo.GetFiles( handle, myProgress, "Callbacks rock!" ) .... } // This is our progress handler. Do something useful like display. // progress percentage. func myProgress(current, total uint64, userdata interface{}) int { fc := float64(current) ft := float64(total) * 0.01 // print how far along we are. // eg: 500 / 1000 (50.00%) // For good measure, prefix it with our userdata value, which // we supplied as "Callbacks rock!". fmt.Printf("%s: %d / %d (%3.2f%%)\n", userdata.(string), current, total, fc / ft) return 0 } 

यह सब बहुत अधिक जटिल है जैसा कि यह है। हमारे पिछले उदाहरण के विपरीत कॉल ऑर्डर में बदलाव नहीं हुआ है, लेकिन हमें श्रृंखला के अंत में दो अतिरिक्त कॉल मिलते हैं:

क्रम निम्नानुसार है:

 foo.GetFiles(....) -> C.goGetFiles(...) -> C.somelib_get_files(..) -> C.goProgressCB(...) -> foo.goProgressCB(...) -> main.myProgress(...) 

यदि आप जीसीसीओ का उपयोग करते हैं तो यह एक भ्रामक प्रस्ताव नहीं है। यह यहां काम करता है:

foo.go

 package main func Add(a, b int) int { return a + b } 

bar.c

 #include <stdio.h> extern int go_add(int, int) __asm__ ("example.main.Add"); int main() { int x = go_add(2, 3); printf("Result: %d\n", x); } 

makefile

 all: main main: foo.o bar.c gcc foo.o bar.c -o main foo.o: foo.go gccgo -c foo.go -o foo.o -fgo-prefix=example clean: rm -f main *.o 

उत्तर 1.5 के रिलीज के साथ उत्तर बदल गया है

यह कुछ सवाल है जो मैंने कुछ समय पहले कहा था कि इस मुद्दे को फिर से 1.5 जोड़ क्षमता के प्रकाश में दिया गया है

किसी मौजूदा सी प्रोजेक्ट में जाओ कोड का उपयोग करना

जहां तक ​​मेरा सवाल है, यह संभव नहीं है:

नोट: यदि आप निर्यात का उपयोग कर रहे हैं तो आप प्रस्तावना में किसी भी सी फंक्शन को परिभाषित नहीं कर सकते

स्रोत: https://github.com/golang/go/wiki/cgo