पर्लक्लिब - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

पर्लक्लिब - मानक सी लाइब्रेरी फ़ंक्शंस के लिए आंतरिक प्रतिस्थापन

वर्णन

पर्ल पोर्टर्स को एक बात ध्यान रखनी चाहिए पर्ल सी का उतना अधिक उपयोग नहीं करता है
आंतरिक रूप से मानक पुस्तकालय; उदाहरण के लिए, आप इसका बहुत कम उपयोग देखेंगे ctype.h
वहां कार्य करता है. ऐसा इसलिए है क्योंकि पर्ल मानक लाइब्रेरी को पुन: कार्यान्वित या अमूर्त करता है
फ़ंक्शन, ताकि हम ठीक से जान सकें कि वे कैसे काम करेंगे।

यह उन लोगों के लिए एक संदर्भ कार्ड है जो सी लाइब्रेरी से परिचित हैं और जो ऐसा करना चाहते हैं
चीज़ें पर्ल तरीके से; उन्हें यह बताने के लिए कि उन्हें अधिक के बजाय किन कार्यों का उपयोग करना चाहिए
सामान्य सी कार्य।

कन्वेंशनों
निम्नलिखित तालिकाओं में:

"टी"
एक प्रकार है.

"पी"
एक सूचक है.

"एन"
एक संख्या है।

"एस"
एक स्ट्रिंग है।

"एसवी", "एवी", "एचवी", आदि अपने संबंधित प्रकार के चर का प्रतिनिधित्व करते हैं।

पट्टिका संचालन
के स्थान पर stdio.h फ़ंक्शंस, आपको पर्ल एब्स्ट्रैक्शन परत का उपयोग करना चाहिए। के बजाय
"फ़ाइल*" प्रकार, आपको "PerlIO*" प्रकार को संभालना होगा। नये के साथ इसे मत भूलना
PerlIO स्तरित I/O अमूर्त "फ़ाइल*" प्रकार भी उपलब्ध नहीं हो सकते हैं। यह भी देखें
निम्नलिखित कार्यों के बारे में अधिक जानकारी के लिए "पर्लापियो" दस्तावेज़:

इसके बजाय: उपयोग करें:

stdin PerlIO_stdin()
stdout PerlIO_stdout()
stderr PerlIO_stderr()

fopen(fn, मोड) PerlIO_open(fn, मोड)
फ्रीओपन(एफएन, मोड, स्ट्रीम) पर्लआईओ_रीओपन(एफएन, मोड, पर्लियो) (डीप-
दोहराया गया)
fflush(स्ट्रीम) PerlIO_flush(perlio)
fclose(स्ट्रीम) PerlIO_close(perlio)

पट्टिका निवेश और उत्पादन
इसके बजाय: उपयोग करें:

fprintf(स्ट्रीम, fmt, ...) PerlIO_printf(perlio, fmt, ...)

[f]getc(स्ट्रीम) PerlIO_getc(perlio)
[एफ]पुटसी(स्ट्रीम, एन) पर्लिओ_पुटसी(पेरिलियो, एन)
ungetc(n, स्ट्रीम) PerlIO_ungetc(perlio, n)

ध्यान दें कि "फ़्रेड" और "फ़राइट" के पर्लिओ समकक्ष उनसे थोड़े अलग हैं
सी लाइब्रेरी समकक्ष:

फ़्रेड (पी, आकार, एन, स्ट्रीम) PerlIO_read (पेर्लियो, buf, numbytes)
fwrite(p, आकार, n, स्ट्रीम) PerlIO_write(perlio, buf, numbytes)

fputs(s, स्ट्रीम) PerlIO_puts(perlio, s)

"फ़गेट्स" का कोई समकक्ष नहीं है; इसके बजाय "sv_gets" का उपयोग करना चाहिए:

fgets(s, n, stream) sv_gets(sv, perlio, संलग्न)

पट्टिका स्थिति निर्धारण
इसके बजाय: उपयोग करें:

feof(स्ट्रीम) PerlIO_eof(perlio)
fseek(धारा, n, कहाँ से) PerlIO_seek(perlio, n, कहाँ से)
रिवाइंड(स्ट्रीम) PerlIO_rewind(पेर्लियो)

fgetpos(स्ट्रीम, पी) PerlIO_getpos(perlio, sv)
fsetpos(स्ट्रीम, p) PerlIO_setpos(perlio, sv)

फेरर(धारा) PerlIO_error(perlio)
क्लीयरर(स्ट्रीम) पर्लिओ_क्लीयरर(पेर्लियो)

याद प्रबंध और तार हैंडलिंग
इसके बजाय: उपयोग करें:

टी* पी = मॉलोक(एन) न्यूएक्स(पी, एन, टी)
t* p = calloc(n, s) Newxz(p, n, t)
पी = रियललोक (पी, एन) नवीनीकरण (पी, एन, टी)
memcpy(dst, src, n) कॉपी(src, dst, n, t)
मेममूव(डीएसटी, एसआरसी, एन) मूव(एसआरसी, डीएसटी, एन, टी)
memcpy(dst, src, sizeof(t)) स्ट्रक्चरकॉपी(src, dst, t)
मेमसेट (डीएसटी, 0, एन * साइजऑफ (टी)) शून्य (डीएसटी, एन, टी)
मेम्ज़ीरो(डीएसटी, 0) शून्य(डीएसटी, एन, चार)
मुफ़्त(पी) सुरक्षितमुक्त(पी)

स्ट्रडअप(पी) सेवपीवी(पी)
strndup(p, n) savepvn(p, n) (अरे, strndup नहीं करता है
अस्तित्व!)

strstr(बड़ा, छोटा) instr(बड़ा, छोटा)
strcmp(s1, s2) strLE(s1, s2) / strEQ(s1, s2)
/ एसटीजीटी (एस 1, एस 2)
strncmp(s1, s2, n) strnNE(s1, s2, n) / strnEQ(s1, s2, n)

मेमसीएमपी(पी1, पी2, एन) मेमएनई(पी1, पी2, एन)
memcmp(p1, p2, n) memEQ(p1, p2, n)

"मेम्सीपीई" और "कॉपी" और "मूव" में प्रयुक्त तर्कों के भिन्न क्रम पर ध्यान दें
"मेममूव"।

हालाँकि, अधिकांश समय, आप कच्चे के बजाय आंतरिक रूप से एसवी से निपटना चाहेंगे
"चार*" तार:

स्ट्रलेन(s) sv_len(sv)
strcpy (डीटी, src) sv_setpv (एसवी, एस)
strncpy(dt, src, n) sv_setpvn(sv, s, n)
strcat(dt, src) sv_catpv(sv, s)
strncat (डीटी, src) sv_catpvn (एसवी, एस)
स्प्रिंटफ़(एस, एफएमटी, ...) sv_setpvf(एसवी, एफएमटी, ...)

"sv_catpvf" और "sv_vcatpvfn" के अस्तित्व पर भी ध्यान दें, जो संयोजन के साथ संयोजन करता है
स्वरूपण।

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

पॉइज़नविथ(डीएसटी, एन, टी, बी) बाइट बी के साथ मेमोरी को स्क्रिबल करें
PoisonNew(dst, n, t) PoisonWith(dst, n, t, 0xAB) के बराबर
PoisonFree(dst, n, t) PoisonWith(dst, n, t, 0xEF) के बराबर
ज़हर(डीएसटी, एन, टी) पॉइज़नफ्री(डीएसटी, एन, टी) के बराबर

चरित्र वर्ग टेस्ट
कई प्रकार के चरित्र वर्ग परीक्षण हैं जिन्हें पर्ल लागू करता है। केवल एक ही
यहां वर्णित वे हैं जो सीधे सी लाइब्रेरी फ़ंक्शंस से मेल खाते हैं जो संचालित होते हैं
8-बिट वर्ण, लेकिन ऐसे समकक्ष भी हैं जो विस्तृत वर्णों और यूटीएफ-8 पर काम करते हैं
एन्कोडेड तार. पेरलापी में "चरित्र वर्गीकरण" में सभी का पूरी तरह से वर्णन किया गया है
और पेरलापी में "कैरेक्टर केस चेंजिंग"।

नीचे दी गई तालिका में सूचीबद्ध सी लाइब्रेरी रूटीन वर्तमान के आधार पर मान लौटाती है
स्थान. उस कार्यक्षमता के लिए अंतिम कॉलम में प्रविष्टियों का उपयोग करें। अन्य दो
कॉलम हमेशा POSIX (या C) लोकेल मानते हैं। केवल ASCII कॉलम में प्रविष्टियाँ हैं
ASCII इनपुट के लिए अर्थपूर्ण, किसी अन्य चीज़ के लिए FALSE लौटाता है। इनका उपयोग तभी करें जब आप
जानना तुम यही चाहते हो. लैटिन1 कॉलम में प्रविष्टियाँ मानती हैं कि गैर-एएससीआईआई
8-बिट वर्ण यूनिकोड की परिभाषा के अनुसार हैं, वे ISO-8859-1 के समान हैं, जिन्हें अक्सर लैटिन कहा जाता है
1.

इसके बजाय: ASCII के लिए उपयोग करें: लैटिन के लिए उपयोग करें1: लोकेल के लिए उपयोग करें:

isalnum(c) isALPHANNUMERIC(c) isALPHANUMERIC_L1(c) isALPHANUMERIC_LC(c)
isalpha(c) isALPHA(c) isALPHA_L1(c) isALPHA_LC(u)
isascii (सी) isASCII (सी) isASCII_LC (सी)
isblank (सी) isBLANK (सी) isBLANK_L1 (सी) isBLANK_LC (सी) है
iscntrl(c) isCNTRL(c) isCNTRL_L1(c) isCNTRL_LC(c)
isdigit(c) isDIGIT(c) isDIGIT_L1(c) isDIGIT_LC(c)
isgraph(c) isGRAPH(c) isGRAPH_L1(c) isGRAPH_LC(c)
islower(c) islower(c) isLOWER_L1(c) isLOWER_LC(c)
isprint(c) isPRINT(c) isPRINT_L1(c) isPRINT_LC(c)
ispunct(c) isPUNCT(c) isPUNCT_L1(c) isPUNCT_LC(c)
isspace(c) isSPACE(c) isSPACE_L1(c) isSPACE_LC(c)
isupper(c) isUPPER(c) isUPPER_L1(c) isUPPER_LC(c)
isxdigit(c) isXDIGIT(c) isXDIGIT_L1(c) isXDIGIT_LC(c)

tolower(c) tolower(c) toLOWER_L1(c) toLOWER_LC(c)
टॉपर(c) सेUPPER(c) toUPPER_LC(c)

इस बात पर जोर देने के लिए कि आप केवल ASCII वर्णों पर काम कर रहे हैं, आप प्रत्येक में "_A" जोड़ सकते हैं
ASCII कॉलम में मैक्रोज़ का: "isALPHA_A", "isDIGIT_A", इत्यादि।

(लैटिन1 कॉलम में "isascii" के लिए कोई प्रविष्टि नहीं है, भले ही वहाँ एक है
"isASCII_L1", जो "isASCII" के समान है; बाद वाला नाम अधिक स्पष्ट है. कोई नहीं है
"टॉपर" के लिए लैटिन1 कॉलम में प्रविष्टि क्योंकि परिणाम गैर-लैटिन1 हो सकता है। आपके पास
"toUPPER_uni" का उपयोग करने के लिए, जैसा कि पर्लापी में "कैरेक्टर केस चेंजिंग" में वर्णित है।)

एसटीडीएलआईबी.एच कार्यों
इसके बजाय: उपयोग करें:

एटोफ़(ओं) एटोफ़(ओं)
atoi(s) grok_atoUV(s, &uv, &e)
एटोल(s) grok_atoUV(s, &uv, &e)
स्ट्रटोड(एस, एंडपी) कुछ भी नहीं। बस इसका उपयोग न करें.
strtol(s, &p, n) grok_atoUV(s, &uv, &e)
strtoul(s, &p, n) grok_atoUV(s, &uv, &e)

कास्टिंग से पहले "यूवी" पर रेंज जांच करना आम तौर पर उपयोग किया जाता है:

int मैं; यूवी यूवी; चार*end_ptr;
यदि (grok_atoUV(इनपुट, &uv, &end_ptr)
&& यूवी <= INT_MAX)
मैं = (int)uv;
... /*end_ptr से पार्सिंग जारी रखें */
और} {
... /* पार्स त्रुटि: श्रेणी 0 में दशमलव पूर्णांक नहीं .. MAX_IV */
}

"grok_bin", "grok_hex", और "grok_oct" फ़ंक्शंस पर भी ध्यान दें संख्यात्मक.सी एसटी
संबंधित आधारों में संख्याओं का प्रतिनिधित्व करने वाली स्ट्रिंग को "एनवी" में परिवर्तित करना। ध्यान दें कि
grok_atoUV() नकारात्मक इनपुट, या अग्रणी व्हाइटस्पेस (उद्देश्यपूर्ण तरीके से) को संभाल नहीं पाता है
कठोर)।

ध्यान दें कि स्ट्रटोल() और स्ट्रटौल() के रूप में प्रच्छन्न हो सकता है स्ट्रटोल(), स्ट्रटौल(), एटोल(), अटौल().
उनसे भी बचें.

सिद्धांत रूप में "Strtool" और "Strtoul" को परिभाषित नहीं किया जा सकता है यदि मशीन पर्ल पर बनाया गया है
वास्तव में strtol और strtoul नहीं है। लेकिन चूंकि वे 2 कार्य 1989 का हिस्सा हैं
एएनएसआई सी युक्ति हमें संदेह है कि आप उन्हें अब तक हर जगह पाएंगे।

पूर्णांक रैंड () डबल Drand01 ()
srand(n) {seedDrand01((Rand_seed_t)n);
PL_srand_call = TRUE; }

बाहर निकलें(n) my_exit(n)
सिस्टम(ओं) मत करो. pp_system देखें या my_popen का उपयोग करें।

getenv(s) PerlEnv_getenv(s)
सेटेनव (एस, वैल) my_setenv (एस, वैल)

कई तरह का कार्यों
आपको भी नहीं करना चाहिए करना चाहते हैं उपयोग करने के लिए सेटजम्प.एच कार्य करता है, लेकिन यदि आपको लगता है कि आप ऐसा करते हैं, तो इसका उपयोग करें
"JMPENV" स्टैक इन दायरा.एच बजाय.

"सिग्नल"/"सिगेक्शन" के लिए, "आरसिग्नल(साइनो, हैंडलर)" का उपयोग करें।

onworks.net सेवाओं का उपयोग करके ऑनलाइन perlclib का उपयोग करें