पर्ल 5: मैक्रोज़ ने त्रुटियों को कैसे छिपाया

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

परिचय

पर्ल एक उच्च-स्तरीय व्याख्या वाली गतिशील सामान्य-प्रयोजन प्रोग्रामिंग भाषा है (पर्ल दो उच्च-स्तरीय, सामान्य-उद्देश्य, व्याख्या की गई, गतिशील प्रोग्रामिंग भाषाओं का परिवार है)। पर्ल 5 को 1994 में लॉन्च किया गया था। कुछ दशकों के बाद, कई मैक्रोज़ के साथ सी कोड आधुनिक प्रोग्रामर के लिए घबराहट का कारण बनता है।

पर्ल 5 के लिए स्रोत कोड आधिकारिक रिपॉजिटरी ( ब्लेड शाखा) से लिया गया था। परियोजना की जांच करने के लिए, हमने पीवीएस-स्टूडियो स्टैटिक कोड एनालाइज़र का उपयोग किया। विश्लेषण लिनक्स ऑपरेटिंग सिस्टम पर आयोजित किया गया था, लेकिन विश्लेषक विंडोज और मैकओएस के लिए भी उपलब्ध है।

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

टर्नरी ऑपरेटर आपके सोचने के तरीके पर काम नहीं करता है

V502 शायद '?:' ऑपरेटर अपेक्षा के अनुरूप काम करता है। '?:' ऑपरेटर की '-' ऑपरेटर की तुलना में कम प्राथमिकता है। toke.c 9494

STATIC char * S_scan_ident(pTHX_ char *s, char *dest, STRLEN destlen, I32 ck_uni) { .... if ((s <= PL_bufend - (is_utf8) ? UTF8SKIP(s) : 1) && VALID_LEN_ONE_IDENT(s, PL_bufend, is_utf8)) { .... } .... } 

एक सुंदर गलती के साथ समीक्षा शुरू करते हैं। हर कुछ कोड समीक्षाओं को दोहराना पड़ता है कि टर्नेरी ऑपरेटर की कंप्यूटिंग में सबसे कम प्राथमिकता है।

त्रुटि के साथ टुकड़े पर विचार करें:

 s <= PL_bufend - (is_utf8) ? UTF8SKIP(s) : 1 

प्रोग्रामर को उम्मीद है कि संचालन का क्रम:

1. ?:
2. -
3. <=

वास्तव में क्या होता है:

1. -
2. <=
3. ?:

संचालन की प्राथमिकताओं के साथ एक लेबल रखें: " सी / सी ++ में संचालन की प्राथमिकता ।"

V502 शायद '?:' ऑपरेटर अपेक्षा के अनुरूप काम करता है। '?:' ऑपरेटर की '==' ऑपरेटर की तुलना में कम प्राथमिकता है। re_exec.c 9193

 STATIC I32 S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, regmatch_info *const reginfo, I32 max _pDEPTH) { .... assert(STR_LEN(p) == reginfo->is_utf8_pat ? UTF8SKIP(STRING(p)) : 1); .... } 

एक समान त्रुटि के साथ सरल कोड। लेकिन अगर आप संचालन की प्राथमिकताओं को नहीं जानते हैं, तो आप किसी भी आकार की अभिव्यक्ति में गलती कर सकते हैं।

मुखर के साथ एक और जगह:

• V502 शायद '?:' ऑपरेटर अपेक्षा के अनुरूप काम करता है। '?:' ऑपरेटर की '==' ऑपरेटर की तुलना में कम प्राथमिकता है। re_exec.c 9286

V502 शायद '?:' ऑपरेटर अपेक्षा के अनुरूप काम करता है। '?:' ऑपरेटर की 'और&' ऑपरेटर की तुलना में कम प्राथमिकता है। pp_hot.c 3036

 PP(pp_match) { .... MgBYTEPOS_set(mg, TARG, truebase, RXp_OFFS(prog)[0].end); .... } 

और यहां मैक्रो के लिए एक चेतावनी है ... यह समझने के लिए कि वहां क्या हो रहा है, यहां तक ​​कि मैक्रो के कार्यान्वयन में मदद नहीं मिलेगी, क्योंकि यह कुछ और मैक्रोज़ का उपयोग करता है!

इसलिए, मैं कोड की इस पंक्ति के लिए प्रीप्रोसेस की गई फ़ाइल का एक टुकड़ा संलग्न करता हूं:

 (((targ)->sv_flags & 0x00000400) && (!((targ)->sv_flags & 0x00200000) || S_sv_only_taint_gmagic(targ)) ? (mg)->mg_len = ((prog->offs)[0].end), (mg)->mg_flags |= 0x40 : ((mg)->mg_len = (((targ)->sv_flags & 0x20000000) && !__builtin_expect(((((PL_curcop)->cop_hints + 0) & 0x00000008) ? (_Bool)1 :(_Bool)0),(0))) ? (ssize_t)Perl_utf8_length( (U8 *)(truebase), (U8 *)(truebase)+((prog->offs)[0].end)) : (ssize_t)((prog->offs)[0].end), (mg)->mg_flags &= ~0x40)); 

यहां कहीं भी, विश्लेषक ने टर्नरी ऑपरेटर के सही उपयोग पर संदेह किया (उनमें से 3 हैं), लेकिन मुझे यह समझने की ताकत नहीं मिली कि इस कोड में क्या किया जा रहा है। हम पहले ही देख चुके हैं कि डेवलपर्स इस तरह की गलतियाँ करते हैं, इसलिए यहाँ भी इसकी संभावना हो सकती है।

इस मैक्रो के तीन और उपयोग:

• V502 शायद '?:' ऑपरेटर अपेक्षा के अनुरूप काम करता है। '?:' ऑपरेटर की 'और&' ऑपरेटर की तुलना में कम प्राथमिकता है। pp_ctl.c 324
• V502 शायद '?:' ऑपरेटर अपेक्षा के अनुरूप काम करता है। '?:' ऑपरेटर की 'और&' ऑपरेटर की तुलना में कम प्राथमिकता है। regexec.c 7335
• V502 शायद '?:' ऑपरेटर अपेक्षा के अनुरूप काम करता है। '?:' ऑपरेटर की 'और&' ऑपरेटर की तुलना में कम प्राथमिकता है। re_exec.c 7335

नोट सहयोगियों आंद्रेई कार्पोव। मैंने 10 मिनट के लिए इस कोड पर ध्यान दिया और मुझे विश्वास है कि कोई त्रुटि नहीं है। लेकिन किसी भी मामले में, इस तरह के कोड को पढ़ना बेहद दर्दनाक है, और इस तरह से लिखना बेहतर नहीं है।

शर्तों में त्रुटियां

V523 'तत्कालीन' कथन 'और' कथन के बराबर है। toke.c 12056

 static U8 * S_add_utf16_textfilter(pTHX_ U8 *const s, bool reversed) { .... SvCUR_set(PL_linestr, 0); if (FILTER_READ(0, PL_linestr, 0)) { SvUTF8_on(PL_linestr); } else { SvUTF8_on(PL_linestr); } PL_bufend = SvEND(PL_linestr); return (U8*)SvPVX(PL_linestr); } 

मुझे लगता है कि आप यह सुनिश्चित करने के लिए मैक्रोज़ की सामग्री की जांच किए बिना कर सकते हैं कि संदिग्ध डुप्लिकेट कोड के टुकड़े हैं।

V564 '' | ' ऑपरेटर को बूल प्रकार के मूल्य पर लागू किया जाता है। आप शायद कोष्ठकों को शामिल करना भूल गए हैं या 'का उपयोग करने का इरादा है' || ऑपरेटर। op.c 11494

 OP * Perl_ck_rvconst(pTHX_ OP *o) { .... gv = gv_fetchsv(kidsv, o->op_type == OP_RV2CV && o->op_private & OPpMAY_RETURN_CONSTANT ? GV_NOEXPAND : iscv | !(kid->op_private & OPpCONST_ENTERED), iscv // <= ? SVt_PVCV : o->op_type == OP_RV2SV ? SVt_PV : o->op_type == OP_RV2AV ? SVt_PVAV : o->op_type == OP_RV2HV ? SVt_PVHV : SVt_PVGV); .... } 

बहुत ही अजीब कोड। अभिव्यक्ति "iscv | ! (बच्चा-> op_pStreet और OPpCONST_ENTERED) "किसी भी तरह से उपयोग नहीं किया जाता है। यहाँ स्पष्ट रूप से एक टाइपो है। उदाहरण के लिए, शायद आपको यहां लिखना चाहिए:

 : iscv = !(kid->op_private & OPpCONST_ENTERED), iscv // <= 

V547 अभिव्यक्ति 'RETVAL == 0' हमेशा सच होती है। टाइपमैप 710

 XS_EUPXS(XS_XS__Typemap_T_SYSRET_pass); XS_EUPXS(XS_XS__Typemap_T_SYSRET_pass) { dVAR; dXSARGS; if (items != 0) croak_xs_usage(cv, ""); { SysRet RETVAL; #line 370 "Typemap.xs" RETVAL = 0; #line 706 "Typemap.c" { SV * RETVALSV; RETVALSV = sv_newmortal(); if (RETVAL != -1) { // <= if (RETVAL == 0) // <= sv_setpvn(RETVALSV, "0 but true", 10); else sv_setiv(RETVALSV, (IV)RETVAL); } ST(0) = RETVALSV; } } XSRETURN(1); } 

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

आकार के ऑपरेटर के बारे में चेतावनी फेंकना

विश्लेषक में कई प्रकार के नैदानिक ​​नियम हैं जो आकार ऑपरेटर के उपयोग से त्रुटियों की तलाश करते हैं। पर्ल 5 परियोजना में, इनमें से दो निदानों ने कुल लगभग एक हजार चेतावनियाँ दीं। इस मामले में, यह विश्लेषणकर्ता नहीं है कि दोष देना है, लेकिन मैक्रोज़।

V568 यह विचित्र है कि sizeof () ऑपरेटर का तर्क 'लेन + 1' अभिव्यक्ति है। उपयोग। 1084

 char * Perl_savepvn(pTHX_ const char *pv, I32 len) { .... Newx(newaddr,len+1,char); .... } 

कोड में कई समान मैक्रो हैं। मैंने एक उदाहरण के रूप में चुना, हम तर्क "लेन + 1" में रुचि रखते हैं।

एक मैक्रो प्रीप्रोसेसर निम्न कोड में फैलता है:

 (newaddr = ((void)(__builtin_expect(((((( sizeof(size_t) < sizeof(len+1) || sizeof(char) > ((size_t)1 << 8*(sizeof(size_t) - sizeof(len+1)))) ? (size_t)(len+1) : ((size_t)-1)/sizeof(char)) > ((size_t)-1)/sizeof(char))) ? (_Bool)1 : (_Bool)0),(0)) && (S_croak_memory_wrap(),0)), (char*)(Perl_safesysmalloc((size_t)((len+1)*sizeof(char)))))); 

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

डेरेफ्रेंसिंग नल पॉइंटर्स

V522 अशक्त सूचक 'sv' की डेरेफेरिंग हो सकती है। pp_ctl.c 577

 OP * Perl_pp_formline(void) { .... SV *sv = ((void *)0); .... switch (*fpc++) { .... case 4: arg = *fpc++; f += arg; fieldsize = arg; if (mark < sp) sv = *++mark; else { sv = &(PL_sv_immortals[2]); Perl_ck_warner( (28 ), "...."); } .... break; case 5: { const char *s = item = ((((sv)->sv_flags & (....)) == 0x00000400) ? .... .... } .... } 

यह कोड टुकड़ा पूरी तरह से प्रीप्रोसेस की गई फ़ाइल से लिया गया है, क्योंकि मैक्रो की वजह से, फिर से स्रोत फ़ाइल से समस्या की उपस्थिति को सत्यापित करना असंभव है।

घोषणा के समय sv प्वाइंटर को शून्य किया जाता है। विश्लेषक ने पाया कि स्विच स्टेटमेंट में 5 से अधिक उत्तीर्ण होने पर, यह पॉइंटर को डिफाइरेक्ट किया जाता है, जिसे पहले कभी भी इनिशियलाइज़ नहीं किया गया था। Sv पॉइंटर में एक परिवर्तन 4 मान के साथ शाखा में मौजूद है, लेकिन कोड के इस ब्लॉक के अंत में ब्रेक स्टेटमेंट है। सबसे अधिक संभावना है, इस जगह में अतिरिक्त कोड की आवश्यकता होती है।

V595 nullptr के खिलाफ सत्यापित होने से पहले 'k' पॉइंटर का उपयोग किया गया था। चेक लाइनें: 15919, 15920. op.c 15919

 void Perl_rpeep(pTHX_ OP *o) { .... OP *k = o->op_next; U8 want = (k->op_flags & OPf_WANT); // <= if ( k // <= && k->op_type == OP_KEYS && ( want == OPf_WANT_VOID || want == OPf_WANT_SCALAR) && !(k->op_private & OPpMAYBE_LVSUB) && !(k->op_flags & OPf_MOD) ) { .... } 

इस कोड स्निपेट में, विश्लेषक को एक पॉइंटर k मिला, जिसे इसकी वैधता जांच से पहले एक पंक्ति में रखा गया है। यह एक गलती या एक अतिरिक्त कोड हो सकता है।

डायग्नोस्टिक्स V595 किसी भी परियोजना में बहुत सारी चेतावनियाँ देता है, पर्ल 5 कोई अपवाद नहीं है। यह सब इस लेख में फिट करना असंभव है, इसलिए हम खुद को एक उदाहरण तक सीमित कर लेंगे, और डेवलपर्स अपनी इच्छा से परियोजना की जांच करेंगे।

अनेक वस्तुओं का संग्रह

V779 अनुपलब्ध कोड का पता चला। यह संभव है कि कोई त्रुटि मौजूद हो। Universal.c 457

 XS(XS_utf8_valid); XS(XS_utf8_valid) { dXSARGS; if (items != 1) croak_xs_usage(cv, "sv"); else { SV * const sv = ST(0); STRLEN len; const char * const s = SvPV_const(sv,len); if (!SvUTF8(sv) || is_utf8_string((const U8*)s,len)) XSRETURN_YES; else XSRETURN_NO; } XSRETURN_EMPTY; } 

XSRETURN_EMPTY के साथ लाइन पर , विश्लेषक ने एक पहुंच योग्य कोड का पता लगाया। इस फ़ंक्शन और croak_xs_usage में दो रिटर्न स्टेटमेंट हैं - एक मैक्रो जो एक नोटरी फ़ंक्शन में विस्तारित है:

 void Perl_croak_xs_usage(const CV *const cv, const char *const params) __attribute__((noreturn)); 

पर्ल 5 कोड में समान स्थानों पर, अनुपलब्ध शाखा को इंगित करने के लिए NOT_REACHED मैक्रो का उपयोग किया जाता है।

V784 बिट मास्क का आकार पहले वाले ऑपरेंड के आकार से कम है। यह उच्च बिट्स के नुकसान का कारण होगा। inffast.c 296

 void ZLIB_INTERNAL inflate_fast(z_streamp strm, unsigned start) { .... unsigned long hold; /* local strm->hold */ unsigned bits; /* local strm->bits */ .... hold &= (1U << bits) - 1; .... } 

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

निष्कर्ष

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

पुनश्च हम निश्चित रूप से इस दिलचस्प परियोजना का समर्थन करना चाहते हैं, और हम कई महीनों के लिए लाइसेंस प्रदान करने के लिए तैयार हैं।

यदि आप इस लेख को अंग्रेजी बोलने वाले दर्शकों के साथ साझा करना चाहते हैं, तो कृपया अनुवाद के लिंक का उपयोग करें: Svyatoslav Razmyslov। पर्ल 5: मैक्रोज़ में त्रुटियों को कैसे छिपाएं