🤘🏻 🤧 👩🏾 पायथन में libclang का उपयोग करके C ++ कोड को पार्स करने का एक उदाहरण 🤶🏻 👎🏼 😀

एक व्यक्तिगत C ++ प्रोजेक्ट पर, मुझे रनटाइम पर ऑब्जेक्ट्स के प्रकारों के बारे में जानकारी प्राप्त करने की आवश्यकता थी। C ++ में एक अंतर्निहित रन-टाइम प्रकार सूचना (RTTI) तंत्र है, और निश्चित रूप से पहला विचार इसका उपयोग करना था, लेकिन मैंने अपने कार्यान्वयन को लिखने का फैसला किया क्योंकि मैं पूरे अंतर्निहित तंत्र को खींचना नहीं चाहता था, क्योंकि मुझे इसकी कार्यक्षमता का केवल एक छोटा हिस्सा चाहिए था। मैं सी ++ 17 की नई विशेषताओं का अभ्यास करने की कोशिश करना चाहता था, जिसके साथ मैं विशेष रूप से परिचित नहीं था।

इस पोस्ट में मैं पायथन में लिबकलंग पार्सर के साथ काम करने का एक उदाहरण प्रस्तुत करूंगा।

मैं अपना RTTI जारी करने के विवरण को छोड़ दूंगा। इस मामले में हमारे लिए महत्वपूर्ण केवल निम्नलिखित बिंदु हैं:

प्रत्येक वर्ग या संरचना जो अपने प्रकार के बारे में जानकारी प्रदान कर सकती है उसे IRttiTypeIdProvider इंटरफ़ेस को इनहेरिट करना होगा;
प्रत्येक ऐसे वर्ग में (यदि यह सार नहीं है), तो आपको RTTI_HAS_TYPE_ID मैक्रो जोड़ना होगा, जो RttiTypeId ऑब्जेक्ट में टाइप पॉइंटर के स्थिर क्षेत्र को जोड़ता है। इस प्रकार, एक प्रकार का पहचानकर्ता प्राप्त करने के लिए, आप MyClass::__typeId लिख सकते हैं या रनटाइम पर कक्षा के एक विशिष्ट उदाहरण getTypeId विधि getTypeId कॉल कर सकते हैं।

एक उदाहरण:

 #pragma once #include <string> #include "RTTI.h" struct BaseNode : public IRttiTypeIdProvider { virtual ~BaseNode() = default; bool bypass = false; }; struct SourceNode : public BaseNode { RTTI_HAS_TYPE_ID std::string inputFilePath; }; struct DestinationNode : public BaseNode { RTTI_HAS_TYPE_ID bool includeDebugInfo = false; std::string outputFilePath; }; struct MultiplierNode : public BaseNode { RTTI_HAS_TYPE_ID double multiplier; }; struct InverterNode : public BaseNode { RTTI_HAS_TYPE_ID };

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

 RTTI_PROVIDER_BEGIN_TYPE(SourceNode) ( RTTI_DEFINE_FIELD(SourceNode, bypass) RTTI_DEFINE_FIELD(SourceNode, inputFilePath) ) RTTI_PROVIDER_END_TYPE() RTTI_PROVIDER_BEGIN_TYPE(DestinationNode) ( RTTI_DEFINE_FIELD(DestinationNode, bypass) RTTI_DEFINE_FIELD(DestinationNode, includeDebugInfo) RTTI_DEFINE_FIELD(DestinationNode, outputFilePath) ) RTTI_PROVIDER_END_TYPE() RTTI_PROVIDER_BEGIN_TYPE(MultiplierNode) ( RTTI_DEFINE_FIELD(MultiplierNode, bypass) RTTI_DEFINE_FIELD(MultiplierNode, multiplier) ) RTTI_PROVIDER_END_TYPE() RTTI_PROVIDER_BEGIN_TYPE(InverterNode) ( RTTI_DEFINE_FIELD(InverterNode, bypass) )

और यह केवल 4 वर्गों के लिए है। किन समस्याओं की पहचान की जा सकती है?

कोड के पेस्ट ब्लॉकों को मैन्युअल रूप से कॉपी करते समय, आप फ़ील्ड को परिभाषित करते समय वर्ग के नाम की दृष्टि खो सकते हैं (हमने ब्लॉक को SourceNode से DestinationNode पर कॉपी किया था, लेकिन SourceNode को गंतव्य फ़ील्ड में परिवर्तित करने के लिए भूल गए)। कंपाइलर सबकुछ छोड़ देगा, एप्लिकेशन गिर भी नहीं सकता है, लेकिन फ़ील्ड के बारे में जानकारी गलत होगी। और यदि आप ऐसे क्षेत्र की जानकारी के आधार पर डेटा रिकॉर्ड करते हैं या पढ़ते हैं, तो सब कुछ विस्फोट हो जाएगा (वे ऐसा कहते हैं, लेकिन मैं खुद इसकी जांच नहीं करना चाहता)।
यदि आप आधार वर्ग के लिए एक फ़ील्ड जोड़ते हैं, तो सभी रिकॉर्ड अपडेट किए जाने चाहिए।
यदि आप कक्षा में फ़ील्ड के नाम या क्रम को बदलते हैं, तो आपको कोड के इस फ़ुटक्लॉथ में नाम और ऑर्डर को अपडेट करना याद रखना चाहिए।

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

इस तरह की समस्याओं को हल करने के लिए पायथन मेरी मदद करता है। लेकिन हम सिर्फ टेम्प्लेट टेक्स्ट के साथ नहीं, बल्कि C ++ सोर्स कोड के आधार पर निर्मित टेक्स्ट के साथ काम कर रहे हैं। हमें C ++ कोड के बारे में जानकारी प्राप्त करने के लिए एक उपकरण की आवश्यकता है, और libclang हमें इसमें मदद करेगा।

लिंबांग क्लैंग के लिए एक उच्च-स्तरीय सी इंटरफ़ेस है। सार सिंटैक्स ट्री (एएसटी) में स्रोत कोड पार्स करने के लिए उपकरण के लिए एक एपीआई प्रदान करता है, पहले से पार्स एएसटीएस लोड करना, एएसटीएस को लोड करना, एएसटी के भीतर तत्वों के लिए भौतिक स्रोत स्थानों की मैपिंग, और अन्य क्लैंग टूलसेट।

विवरण के अनुसार, लिबक्लैंग एक सी-इंटरफ़ेस प्रदान करता है, और पायथन के माध्यम से इसके साथ काम करने के लिए आपको एक बाध्यकारी पुस्तकालय (बाइंडिंग) की आवश्यकता होती है। इस पोस्ट को लिखने के समय पायथन के लिए कोई आधिकारिक पुस्तकालय नहीं है, लेकिन अनौपचारिक से यह https://github.com/ethanhs/clang है ।

पैकेज प्रबंधक के माध्यम से इसे स्थापित करें:

 pip install clang

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

आइए एक सरल उदाहरण से शुरू करें:

 import clang.cindex index = clang.cindex.Index.create() translation_unit = index.parse('my_source.cpp', args=['-std=c++17']) for i in translation_unit.get_tokens(extent=translation_unit.cursor.extent): print (i.kind)

यहां एक प्रकार का Index बनाया गया है जो C ++ कोड वाली फाइल को पार्स कर सकता है। parse विधि TranslationUnit यूनाइट की एक वस्तु लौटाती है, यह कोड ट्रांसलेशन की एक इकाई है। TranslUnit एक AST नोड है, और प्रत्येक AST नोड स्रोत कोड (सीमा) में इसकी स्थिति के बारे में जानकारी संग्रहीत करता है। हम TranslUnit में सभी टोकन के माध्यम से लूप करते हैं और इन टोकन के प्रकार (प्रॉपर्टी) को प्रिंट करते हैं।

उदाहरण के लिए, निम्नलिखित C ++ कोड लें:

 class X {}; class Y {}; class Z : public X {};

स्क्रिप्ट निष्पादन परिणाम

 TokenKind.KEYWORD TokenKind.IDENTIFIER TokenKind.PUNCTUATION TokenKind.PUNCTUATION TokenKind.PUNCTUATION TokenKind.KEYWORD TokenKind.IDENTIFIER TokenKind.PUNCTUATION TokenKind.PUNCTUATION TokenKind.PUNCTUATION TokenKind.KEYWORD TokenKind.IDENTIFIER TokenKind.PUNCTUATION TokenKind.KEYWORD TokenKind.IDENTIFIER TokenKind.PUNCTUATION TokenKind.PUNCTUATION TokenKind.PUNCTUATION

अब आइए AST को संभालें। पायथन कोड लिखने से पहले, आइए देखें कि हमें क्लैंग पार्सर से क्या उम्मीद करनी चाहिए। एएसटी डंप मोड में क्लैंग चलाएँ:

 clang++ -cc1 -ast-dump my_source.cpp

आज्ञा का परिणाम

 TranslationUnitDecl 0xaaaa9b9fa8 <<invalid sloc>> <invalid sloc> |-TypedefDecl 0xaaaa9ba880 <<invalid sloc>> <invalid sloc> implicit __int128_t '__int128' | `-BuiltinType 0xaaaa9ba540 '__int128' |-TypedefDecl 0xaaaa9ba8e8 <<invalid sloc>> <invalid sloc> implicit __uint128_t 'unsigned __int128' | `-BuiltinType 0xaaaa9ba560 'unsigned __int128' |-TypedefDecl 0xaaaa9bac48 <<invalid sloc>> <invalid sloc> implicit __NSConstantString '__NSConstantString_tag' | `-RecordType 0xaaaa9ba9d0 '__NSConstantString_tag' | `-CXXRecord 0xaaaa9ba938 '__NSConstantString_tag' |-TypedefDecl 0xaaaa9e6570 <<invalid sloc>> <invalid sloc> implicit __builtin_ms_va_list 'char *' | `-PointerType 0xaaaa9e6530 'char *' | `-BuiltinType 0xaaaa9ba040 'char' |-TypedefDecl 0xaaaa9e65d8 <<invalid sloc>> <invalid sloc> implicit __builtin_va_list 'char *' | `-PointerType 0xaaaa9e6530 'char *' | `-BuiltinType 0xaaaa9ba040 'char' |-CXXRecordDecl 0xaaaa9e6628 <my_source.cpp:1:1, col:10> col:7 referenced class X definition | |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param | | |-MoveConstructor exists simple trivial needs_implicit | | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param | | |-MoveAssignment exists simple trivial needs_implicit | | `-Destructor simple irrelevant trivial needs_implicit | `-CXXRecordDecl 0xaaaa9e6748 <col:1, col:7> col:7 implicit class X |-CXXRecordDecl 0xaaaa9e6800 <line:3:1, col:10> col:7 class Y definition | |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param | | |-MoveConstructor exists simple trivial needs_implicit | | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param | | |-MoveAssignment exists simple trivial needs_implicit | | `-Destructor simple irrelevant trivial needs_implicit | `-CXXRecordDecl 0xaaaa9e6928 <col:1, col:7> col:7 implicit class Y `-CXXRecordDecl 0xaaaa9e69e0 <line:5:1, col:21> col:7 class Z definition |-DefinitionData pass_in_registers empty standard_layout trivially_copyable trivial literal has_constexpr_non_copy_move_ctor can_const_default_init | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param | |-MoveConstructor exists simple trivial needs_implicit | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param | |-MoveAssignment exists simple trivial needs_implicit | `-Destructor simple irrelevant trivial needs_implicit |-public 'X' `-CXXRecordDecl 0xaaaa9e6b48 <col:1, col:7> col:7 implicit class Z

यहाँ CXXRecordDecl नोड का प्रकार है जो वर्ग घोषणा का प्रतिनिधित्व करता है। आप देख सकते हैं कि स्रोत फ़ाइल में कक्षाओं की तुलना में अधिक ऐसे नोड हैं। ऐसा इसलिए है क्योंकि संदर्भ नोड्स को उसी प्रकार से दर्शाया जाता है, अर्थात नोड्स जो अन्य नोड्स के लिंक हैं। हमारे मामले में, बेस क्लास को निर्दिष्ट करना संदर्भ है। इस पेड़ को अलग करते समय, आप एक विशेष ध्वज का उपयोग करके संदर्भ नोड निर्धारित कर सकते हैं।

अब हम एक स्क्रिप्ट लिखेंगे जो स्रोत फ़ाइल में कक्षाओं को सूचीबद्ध करेगी:

 import clang.cindex import typing index = clang.cindex.Index.create() translation_unit = index.parse('my_source.cpp', args=['-std=c++17']) def filter_node_list_by_node_kind( nodes: typing.Iterable[clang.cindex.Cursor], kinds: list ) -> typing.Iterable[clang.cindex.Cursor]: result = [] for i in nodes: if i.kind in kinds: result.append(i) return result all_classes = filter_node_list_by_node_kind(translation_unit.cursor.get_children(), [clang.cindex.CursorKind.CLASS_DECL, clang.cindex.CursorKind.STRUCT_DECL]) for i in all_classes: print (i.spelling)

वर्ग का नाम spelling संपत्ति में संग्रहीत है। विभिन्न प्रकार के नोड्स के लिए, spelling मूल्य में कुछ प्रकार के संशोधक हो सकते हैं, लेकिन एक वर्ग या संरचना की घोषणा के लिए, इसमें संशोधक के बिना एक नाम होता है।

निष्पादन परिणाम:

 X Y Z

पार्सिंग करते समय, एएसटी क्लैंग भी #include माध्यम से जुड़ी फाइलों को पार्स करता है। स्रोत में #include <string> जोड़ने की कोशिश करें, और डंप में आपको 84 हजार लाइनें मिलेंगी, जो जाहिर तौर पर हमारी समस्या को हल करने के लिए थोड़ा बहुत है।

कमांड लाइन के माध्यम से ऐसी फ़ाइलों के एएसटी डंप को देखने के लिए, सभी #include को हटाना बेहतर है। जब आप एएसटी का अध्ययन करते हैं और ब्याज की फाइल में पदानुक्रम और प्रकारों का एक विचार प्राप्त करते हैं तो उन्हें वापस लाएं।

स्क्रिप्ट में, केवल स्रोत फ़ाइल से संबंधित AST को फ़िल्टर करने के लिए, और #include माध्यम से कनेक्ट नहीं होने पर, आप फ़ाइल द्वारा निम्न फ़िल्टरिंग फ़ंक्शन जोड़ सकते हैं:

 def filter_node_list_by_file( nodes: typing.Iterable[clang.cindex.Cursor], file_name: str ) -> typing.Iterable[clang.cindex.Cursor]: result = [] for i in nodes: if i.location.file.name == file_name: result.append(i) return result ... filtered_ast = filter_by_file(translation_unit.cursor, translation_unit.spelling)

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

पूर्ण स्क्रिप्ट कोड

 import clang.cindex import typing index = clang.cindex.Index.create() translation_unit = index.parse('Input.h', args=['-std=c++17']) def filter_node_list_by_file( nodes: typing.Iterable[clang.cindex.Cursor], file_name: str ) -> typing.Iterable[clang.cindex.Cursor]: result = [] for i in nodes: if i.location.file.name == file_name: result.append(i) return result def filter_node_list_by_node_kind( nodes: typing.Iterable[clang.cindex.Cursor], kinds: list ) -> typing.Iterable[clang.cindex.Cursor]: result = [] for i in nodes: if i.kind in kinds: result.append(i) return result def is_exposed_field(node): return node.access_specifier == clang.cindex.AccessSpecifier.PUBLIC def find_all_exposed_fields( cursor: clang.cindex.Cursor ): result = [] field_declarations = filter_node_list_by_node_kind(cursor.get_children(), [clang.cindex.CursorKind.FIELD_DECL]) for i in field_declarations: if not is_exposed_field(i): continue result.append(i.displayname) return result source_nodes = filter_node_list_by_file(translation_unit.cursor.get_children(), translation_unit.spelling) all_classes = filter_node_list_by_node_kind(source_nodes, [clang.cindex.CursorKind.CLASS_DECL, clang.cindex.CursorKind.STRUCT_DECL]) class_inheritance_map = {} class_field_map = {} for i in all_classes: bases = [] for node in i.get_children(): if node.kind == clang.cindex.CursorKind.CXX_BASE_SPECIFIER: referenceNode = node.referenced bases.append(node.referenced) class_inheritance_map[i.spelling] = bases for i in all_classes: fields = find_all_exposed_fields(i) class_field_map[i.spelling] = fields def populate_field_list_recursively(class_name: str): field_list = class_field_map.get(class_name) if field_list is None: return [] baseClasses = class_inheritance_map[class_name] for i in baseClasses: field_list = populate_field_list_recursively(i.spelling) + field_list return field_list rtti_map = {} for class_name, class_list in class_inheritance_map.items(): rtti_map[class_name] = populate_field_list_recursively(class_name) for class_name, field_list in rtti_map.items(): wrapper_template = """\ RTTI_PROVIDER_BEGIN_TYPE(%s) ( %s ) RTTI_PROVIDER_END_TYPE() """ rendered_fields = [] for f in field_list: rendered_fields.append(" RTTI_DEFINE_FIELD(%s, %s)" % (class_name, f)) print (wrapper_template % (class_name, ",\n".join(rendered_fields)))

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

मुझे उम्मीद है कि कोई उपयोगी होगा और समय बचाएगा। सभी कोड GitHub पर पोस्ट किया गया है ।

पायथन में libclang का उपयोग करके C ++ कोड को पार्स करने का एक उदाहरण

More articles: