2009-10-14 16 views
13

पर माइग्रेट करते समय 64-बिट्स के लिए भी तैयार कैसे करें क्योंकि अगले संस्करण में 64 बिट्स समर्थन की उम्मीद नहीं है, यह अब हमारे मौजूदा कोड बेस को यूनिकोड और 64 पर माइग्रेट करने की संभावना का इंतजार करने का विकल्प नहीं है एक बार में जाओ। हालांकि यह अच्छा होगा अगर हम अपने यूनिकोड अनुवाद करते समय 64-बिट के लिए पहले से ही अपना कोड तैयार कर सकें। यह अंततः संस्करण 2020 में दिखाई देने वाली घटना में प्रभाव को कम करेगा। कोई सुझाव यह है कि 2020 तक पहुंचने पर बहुत अधिक अव्यवस्था के बिना इसे कैसे पहुंचाया जाए?डेल्फी 2010 और यूनिकोड

+1

निम्नलिखित प्रश्न भी कुछ मदद की हो सकती है: http://stackoverflow.com/questions/4051603/how-should-i-prepare-my-32-bit-delphi-programs-for-an- अंतिम -64-बिट-कंपाइलर – Justin

उत्तर

7

सबसे पहले, उन स्थानों को देखें जहां आप गैर-डेल्फी पुस्तकालयों और एपीआई-कॉल, से इंटरैक्ट करते हैं, वे भिन्न हो सकते हैं। Win32 पर, stdcall कॉलिंग संयोजक वाले पुस्तकालयों को _SomeFunction @ 4 (पैरामीटर के आकार को इंगित करने वाला @ 4) नाम दिया गया है। Win64 पर, केवल एक कॉलिंग सम्मेलन है, और एक डीएल में कार्य अब और सजाए गए नहीं हैं। यदि आप डीएलएल फाइलों से फ़ंक्शंस आयात करते हैं, तो आपको उन्हें समायोजित करने की आवश्यकता हो सकती है।

ध्यान रखें, 64 बिट एक्सई में आप 32-बिट डीएल लोड नहीं कर सकते हैं, इसलिए, यदि आप तृतीय पक्ष डीएल फाइलों पर निर्भर हैं, तो आपको उन फ़ाइलों के 64-बिट संस्करण की भी जांच करनी चाहिए।

इसके अलावा, यदि आप अपने अधिकतम मूल्य पर निर्भर करते हैं, तो इंटीग्रर्स को देखें, उदाहरण के लिए जब आप उन्हें ओवरफ्लो देते हैं और उस क्षण के लिए प्रतीक्षा करते हैं, तो एक पूर्णांक का आकार बदल जाता है तो इससे परेशानी होगी।

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

तो, उन स्थानों पर जहां आप एक पूर्णांक या सूचक के आकार पर निर्भर करते हैं, आपको समायोजन करने की आवश्यकता होगी। जब सुशी डेटा को क्रमबद्ध करते हैं, तो आपको इस आकार के मुद्दे को भी ध्यान में रखना होगा, क्योंकि यह 32 और 64 बिट संस्करणों के बीच डेटा असंगतताओं का कारण बन सकता है।

इसके अलावा, लाज़र आईडीई के साथ फ्रीपास्कल कंपाइलर पहले ही 64-बिट का समर्थन करता है। यह वैकल्पिक ऑब्जेक्ट पास्कल कंपाइलर पास्कल के बोर्लैंड/कोडेगियर/एम्बरकैडेरो बोलीभाषा के साथ 100% संगत नहीं है, इसलिए 64-बिट के लिए बस इसके साथ पुनः संकलन करना इतना आसान नहीं हो सकता है, लेकिन यह 64-बिट के साथ समस्याओं को इंगित करने में मदद कर सकता है।

6

64 बिट में रूपांतरण बहुत दर्दनाक नहीं होना चाहिए। एक पूर्णांक के आकार के बारे में जानबूझकर होने के साथ शुरू करें जहां यह महत्वपूर्ण है। इसके बजाय "पूर्णांक" का उपयोग न करें 32 बिट्स पर पूर्णांक के लिए Int32 का उपयोग करें, और 64 बिट्स पर पूर्णांक के लिए Int64 का उपयोग करें। अंतिम बिट रूपांतरण में इंटीजर की परिभाषा Int16 से Int32 तक चली गई, इसलिए आप सटीक बिट गहराई को निर्दिष्ट करके इसे सुरक्षित बनाते हैं।

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

+3

पूर्णांक के आकार पर भरोसा करने का एक विशेष मामला पूर्णांक और पॉइंटर्स पर निर्भर करता है * समान * आकार, जो भी आकार हो सकता है। साथ ही, यह मानते हुए कि पूर्णांक और * हैंडल * एक ही आकार हैं। डेल्फी आज पूर्णांक के रूप में संभालता है, लेकिन एपीआई उन्हें पॉइंटर्स के रूप में परिभाषित करता है। –

2

जाली पॉइंटर्स वाले पूर्णांक के लिए मूल INT का उपयोग करें।

+1

स्पष्टीकरण के लिए: हस्ताक्षर किए गए और हस्ताक्षरित प्रकार जिन्हें पॉइंटर्स (यानी, 32 या 64 बिट्स) के समान आकार की आवश्यकता होती है, को क्रमशः मूल और मूलभूत के रूप में घोषित किया जा सकता है। – PhiS

20

वहाँ another similar question है, लेकिन मैं यहाँ भी मेरा जवाब दोहराने की आवश्यकता होगी, यह सुनिश्चित करने के रूप में कई लोगों को यह जानकारी देखें:

सबसे पहले, एक अस्वीकरण: हालांकि मैं Embarcadero के लिए काम करते हैं। मैं अपने नियोक्ता के लिए बात नहीं कर सकता। जो मैं लिखने वाला हूं, वह इस बारे में मेरी राय पर आधारित है कि कैसे एक काल्पनिक 64-बिट डेल्फी को काम करना चाहिए, लेकिन प्रतिस्पर्धी राय और अन्य भविष्यवाणी या अप्रत्याशित असंगतताओं और घटनाएं हो सकती हैं जो वैकल्पिक डिजाइन निर्णय लेने का कारण बनती हैं।

कहा:

  • वहाँ दो पूर्णांक प्रकार, NativeInt और NativeUInt, जिसका आकार 32-बिट और 64-बिट के बीच नाव प्लेटफ़ॉर्म के आधार पर होगा। वे कुछ रिलीज के लिए रहे हैं। लक्ष्य के आधार पर कोई अन्य पूर्णांक प्रकार आकार बदल जाएगा।

  • सुनिश्चित करें कि किसी भी जगह है कि एक पूर्णांक या ठीक इसके विपरीत एक सूचक मूल्य कास्टिंग पर निर्भर करता है पूर्णांक प्रकार के लिए NativeInt या NativeUInt उपयोग कर रहा है। TComponent.Tag डेल्फी के बाद के संस्करणों में मूल होना चाहिए।

  • मेरा सुझाव था गैर सूचक आधारित मूल्यों के लिए NativeInt या NativeUInt प्रयोग नहीं करते। अपने कोड को 32-बिट और 64-बिट के बीच समान रूप से समान रखने की कोशिश करें। यदि आपको 32 बिट्स रेंज की आवश्यकता है, तो इंटेजर का उपयोग करें; यदि आपको 64 बिट्स की आवश्यकता है, तो Int64 का उपयोग करें। इस तरह आपका कोड दोनों ही गवाहों पर समान होना चाहिए। केवल तभी जब आप किसी प्रकार के पॉइंटर वैल्यू से और उसके जैसे किसी संदर्भ या थंडल कास्टिंग कर रहे हैं, तो क्या आपको नेटिवइन्ट का उपयोग करना चाहिए।

  • सूचक-तरह बातें संकेत के लिए इसी तरह के नियमों का पालन करना चाहिए: वस्तु संदर्भ (जाहिर है), लेकिन यह भी HWND, THandle, आदि जैसी चीजों

  • तार और गतिशील सरणियों के आंतरिक विवरण पर विश्वास न करें , उनके हेडर डेटा की तरह।

  • हमारे 64-बिट के लिए एपीआई परिवर्तन पर सामान्य नीति भले ही इसका मतलब है कि 64-बिट एपीआई जरूरी फायदा नहीं उठाता है 32-बिट और 64-बिट जहां संभव हो के बीच ही एपीआई रखने के लिए होना चाहिए, मशीन का उदाहरण के लिए, टीएलआईस्ट शायद गिनती, इंडेक्स इत्यादि को इंटीजर के रूप में रखने के लिए मैक्सिंट div SizeOf (पॉइंटर) तत्वों को संभालेगा। चूंकि इंटीजर प्रकार फ्लोट नहीं करेगा (यानी बिहार के आधार पर परिवर्तन आकार), हम ग्राहक कोड पर लहर प्रभाव नहीं चाहते हैं: किसी भी इंडेक्स जो एक इंटीजर-टाइपेड चर के माध्यम से गोल-फिसल गया है, या फॉर-लूप इंडेक्स, काटा जाएगा और संभावित रूप से सूक्ष्म बग का कारण बन जाएगा।

  • कहाँ एपीआई 64-बिट के लिए बढ़ा दिया जाता है, वे सबसे अधिक संभावना अतिरिक्त डेटा का उपयोग करने के साथ किया जाएगा एक अतिरिक्त समारोह/विधि/संपत्ति है, और इस एपीआई भी 32-बिट में समर्थन किया जाएगा। उदाहरण के लिए, लंबाई() मानक दिनचर्या शायद प्रकार स्ट्रिंग या गतिशील सरणी के तर्कों के लिए प्रकार इंटीजर के मान वापस कर देगा; यदि कोई बहुत बड़े गतिशील सरणी से निपटना चाहता है, तो एक लम्बाईथेंथ() दिनचर्या भी हो सकती है, जिसका 32-बिट में कार्यान्वयन लंबाई() के समान है। लंबाई() को 64-बिट में अपवाद फेंक देगा यदि 232 तत्वों के साथ गतिशील सरणी पर लागू होता है।

  • इससे संबंधित, शायद भाषा में संकीर्ण संचालन के लिए त्रुटि जांच में सुधार होगा, विशेष रूप से 64-बिट मान को 32-बिट स्थानों पर संकुचित कर देगा। अगर लंबाई(), इंट 64 लौटा दी गई है तो यह टाइपिंग इंटीजर के स्थानों पर लंबाई के वापसी मूल्य को असाइन करने की उपयोगिता को प्रभावित करेगा।दूसरी तरफ, विशेष रूप से कंपाइलर-जादू लंबाई() जैसे कार्यों के लिए, जादू के कुछ लाभ हो सकते हैं, उदा। संदर्भ के आधार पर वापसी प्रकार स्विच करें। लेकिन लाभ गैर-जादू एपीआई में समान रूप से नहीं लिया जा सकता है।

  • गतिशील सरणी शायद 64-बिट अनुक्रमण का समर्थन करेंगे। ध्यान दें कि जावा सरणी 64-बिट प्लेटफ़ॉर्म पर भी 32-बिट अनुक्रमण तक सीमित हैं।

  • स्ट्रिंग्स शायद 32-बिट अनुक्रमण तक सीमित होंगे। हमारे पास समय 4 जीबी + स्ट्रिंग्स चाहते हैं जो वास्तव में तार हैं, न केवल डेटा के प्रबंधित ब्लॉब्स के लिए यथार्थवादी कारणों के साथ आ रहे हैं, जिसके लिए गतिशील सरणी भी ठीक से सेवा कर सकती है।

  • शायद एक अंतर्निहित असेंबलर, लेकिन प्रतिबंधों के साथ, जैसे डेल्फी कोड के साथ स्वतंत्र रूप से मिश्रण करने में सक्षम नहीं है; अपवादों और ढेर फ्रेम लेआउट के आसपास नियम भी हैं जिन्हें x64 पर पालन करने की आवश्यकता है।

संबंधित मुद्दे