പെർലാപി - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

perlapi - perl പബ്ലിക് API-യ്‌ക്കായുള്ള ഓട്ടോജെനറേറ്റഡ് ഡോക്യുമെന്റേഷൻ

വിവരണം

ഈ ഫയലിൽ സൃഷ്‌ടിച്ച perl പബ്ലിക് API-യുടെ ഡോക്യുമെന്റേഷൻ അടങ്ങിയിരിക്കുന്നു embed.pl,
പ്രത്യേകമായി ഉപയോഗിച്ചേക്കാവുന്ന ഫംഗ്‌ഷനുകൾ, മാക്രോകൾ, ഫ്ലാഗുകൾ, വേരിയബിളുകൾ എന്നിവയുടെ ഒരു ലിസ്‌റ്റിംഗ്
വിപുലീകരണ എഴുത്തുകാർ. അവസാനം ഇതുവരെ ഡോക്യുമെന്റ് ചെയ്യപ്പെടാത്ത പ്രവർത്തനങ്ങളുടെ ഒരു ലിസ്റ്റ് ഉണ്ട്.
അവയുടെ ഇന്റർഫേസുകൾ അറിയിപ്പ് കൂടാതെ മാറ്റത്തിന് വിധേയമാണ്. ഇവിടെ ലിസ്റ്റുചെയ്യാത്തതെന്തും
പൊതു API-യുടെ ഭാഗമല്ല, കൂടാതെ എക്സ്റ്റൻഷൻ റൈറ്റർമാർ ഉപയോഗിക്കാനും പാടില്ല. ഇവർക്കായി
കാരണങ്ങൾ, എഴുതുമ്പോൾ proto.h-ൽ ലിസ്റ്റ് ചെയ്തിരിക്കുന്ന ഫംഗ്‌ഷനുകൾ അന്ധമായി ഉപയോഗിക്കുന്നത് ഒഴിവാക്കേണ്ടതാണ്
വിപുലീകരണങ്ങൾ.

എല്ലാ Perl API ഗ്ലോബൽ വേരിയബിളുകളും "PL_" പ്രിഫിക്‌സ് ഉപയോഗിച്ചായിരിക്കണം പരാമർശിക്കേണ്ടത് എന്നത് ശ്രദ്ധിക്കുക. വീണ്ടും,
ഇവിടെ ലിസ്റ്റുചെയ്തിട്ടില്ലാത്തവ എക്സ്റ്റൻഷൻ റൈറ്റർമാർ ഉപയോഗിക്കാൻ പാടില്ല, അവ മാറ്റാവുന്നതാണ് അല്ലെങ്കിൽ
നോട്ടീസ് നൽകാതെ നീക്കം ചെയ്തു; മാക്രോകൾ പോലെ തന്നെ. അനുയോജ്യതയ്ക്കായി ചില മാക്രോകൾ നൽകിയിട്ടുണ്ട്
പഴയ, അലങ്കരിച്ച പേരുകൾ, എന്നാൽ ഈ പിന്തുണ ഭാവി റിലീസിൽ പ്രവർത്തനരഹിതമാക്കിയേക്കാം.

പേൾ യഥാർത്ഥത്തിൽ US-ASCII കൈകാര്യം ചെയ്യാൻ എഴുതിയതാണ് (അതായത് ഓർഡിനലുള്ള പ്രതീകങ്ങളാണ്
സംഖ്യകൾ 0 - 127 പരിധിയിലാണ്). ഡോക്യുമെന്റേഷനും അഭിപ്രായങ്ങളും ഇപ്പോഴും ഈ പദം ഉപയോഗിച്ചേക്കാം
ASCII, ചിലപ്പോൾ യഥാർത്ഥത്തിൽ 0 മുതൽ 255 വരെയുള്ള മുഴുവൻ ശ്രേണിയും അർത്ഥമാക്കുമ്പോൾ.

ASCII അല്ലെങ്കിൽ EBCDIC (perlebcdic കാണുക) പ്രകാരം പേൾ കംപൈൽ ചെയ്യാനും പ്രവർത്തിപ്പിക്കാനും കഴിയുമെന്നത് ശ്രദ്ധിക്കുക.
മിക്ക ഡോക്യുമെന്റേഷനുകളും (കോഡിലെ അഭിപ്രായങ്ങൾ പോലും) EBCDIC സാധ്യതയെ അവഗണിക്കുന്നു.
മിക്കവാറും എല്ലാ ആവശ്യങ്ങൾക്കും വ്യത്യാസങ്ങൾ സുതാര്യമാണ്. ഉദാഹരണമായി, EBCDIC പ്രകാരം,
UTF-8-ന് പകരം, UTF-EBCDIC യൂണികോഡ് സ്ട്രിംഗുകൾ എൻകോഡ് ചെയ്യാൻ ഉപയോഗിക്കുന്നു, അങ്ങനെ എപ്പോഴെങ്കിലും
ഡോക്യുമെന്റേഷൻ "utf8" (ആ പേരിന്റെ വകഭേദങ്ങൾ, ഫംഗ്‌ഷൻ പേരുകൾ ഉൾപ്പെടെ) സൂചിപ്പിക്കുന്നു.
അത് (അടിസ്ഥാനപരമായി സുതാര്യമായി) അർത്ഥമാക്കുന്നത് "UTF-EBCDIC" എന്നാണ്. എന്നാൽ കഥാപാത്രങ്ങളുടെ ക്രമങ്ങൾ
ASCII, EBCDIC, UTF- എൻകോഡിംഗുകൾ, UTF-EBCDIC എന്നിവയിൽ എൻകോഡ് ചെയ്ത ഒരു സ്ട്രിംഗ് എന്നിവ തമ്മിൽ വ്യത്യാസമുണ്ട്
UTF-8-നേക്കാൾ കൂടുതൽ ബൈറ്റുകൾ കൈവശപ്പെടുത്തിയേക്കാം.

ചുവടെയുള്ള ലിസ്‌റ്റിംഗ് അക്ഷരമാലാ ക്രമത്തിലാണ്, കേസ് സെൻസിറ്റീവ് അല്ല.

"ഗിമ്മെ" മൂല്യങ്ങൾ

GIMME "G_SCALAR" അല്ലെങ്കിൽ മാത്രം നൽകാനാകുന്ന "GIMME_V"-ന്റെ പിന്നാക്ക-അനുയോജ്യ പതിപ്പ്
"G_ARRAY"; ശൂന്യമായ സന്ദർഭത്തിൽ, അത് "G_SCALAR" നൽകുന്നു. ഒഴിവാക്കി. "GIMME_V" ഉപയോഗിക്കുക
പകരം.

U32 GIMME

GIMME_V പേളിന്റെ "wantarray" ന് തുല്യമായ XSUB-എഴുത്തുകാരൻ. "G_VOID", "G_SCALAR" എന്നിവ നൽകുന്നു
അല്ലെങ്കിൽ "G_ARRAY" യഥാക്രമം അസാധുവായ, സ്കെയിലർ അല്ലെങ്കിൽ ലിസ്റ്റ് സന്ദർഭത്തിന്. a എന്നതിനായി perlcall കാണുക
ഉപയോഗ ഉദാഹരണം.

U32 GIMME_V

ലിസ്റ്റ് സന്ദർഭം സൂചിപ്പിക്കാൻ G_ARRAY ഉപയോഗിക്കുന്നു. "GIMME_V", "GIMME", perlcall എന്നിവ കാണുക.

G_DISCARD
ഒരു കോൾബാക്കിൽ നിന്ന് ലഭിച്ച വാദങ്ങൾ നിരസിക്കണമെന്ന് സൂചിപ്പിക്കുന്നു. കാണുക
perlcall.

G_EVAL ഒരു കോൾബാക്കിന് ചുറ്റും പേൾ "ഇവൽ" റാപ്പർ നിർബന്ധിക്കാൻ ഉപയോഗിക്കുന്നു. perlcall കാണുക.

G_NOARGS
ഒരു കോൾബാക്കിലേക്ക് വാദങ്ങളൊന്നും അയച്ചിട്ടില്ലെന്ന് സൂചിപ്പിക്കുന്നു. perlcall കാണുക.

G_SCALAR
സ്കെയിലർ സന്ദർഭം സൂചിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു. "GIMME_V", "GIMME", perlcall എന്നിവ കാണുക.

G_VOID ശൂന്യമായ സന്ദർഭം സൂചിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു. "GIMME_V" കാണുകയും perlcall ചെയ്യുക.

അറേ കൃത്രിമം പ്രവർത്തനങ്ങൾ

AvFILL "av_top_index()" പോലെ തന്നെ. ഒഴിവാക്കി, പകരം "av_top_index()" ഉപയോഗിക്കുക.

int AvFILL(AV* av)

av_clear
ഒരു അറേയുടെ എല്ലാ ഘടകങ്ങളും സ്വതന്ത്രമാക്കുന്നു, അത് ശൂന്യമാക്കി. XS ന് തുല്യമാണ്
"@അറേ = ()". "av_undef" എന്നതും കാണുക.

ഒരു ഡിസ്ട്രക്റ്ററുടെ പ്രവർത്തനങ്ങൾ നേരിട്ട് വിളിക്കപ്പെടാൻ സാധ്യതയുണ്ടെന്ന കാര്യം ശ്രദ്ധിക്കുക
പരോക്ഷമായി അറേയുടെ ഒരു ഘടകം സ്വതന്ത്രമാക്കുന്നത് റഫറൻസ് എണ്ണത്തിന് കാരണമാകും
അറേ തന്നെ കുറയ്ക്കണം (ഉദാ: ചിഹ്ന പട്ടികയിലെ ഒരു എൻട്രി ഇല്ലാതാക്കുന്നതിലൂടെ). അങ്ങനെ
AV സ്വതന്ത്രമാക്കപ്പെടാനുള്ള (അല്ലെങ്കിൽ വീണ്ടും സ്ഥാപിതമായ) ഒരു സാധ്യതയാണ്
നിങ്ങൾ ഒരു റഫറൻസ് കൈവശം വച്ചില്ലെങ്കിൽ കോളിൽ നിന്ന് മടങ്ങുക.

void av_clear(AV *av)

av_create_and_push
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

അറേയുടെ അറ്റത്തേക്ക് ഒരു SV അമർത്തുക, ആവശ്യമെങ്കിൽ അറേ സൃഷ്ടിക്കുക. ഒരു ചെറിയ
സാധാരണയായി ഡ്യൂപ്ലിക്കേറ്റഡ് ഐഡിയം നീക്കം ചെയ്യുന്നതിനുള്ള ആന്തരിക സഹായ പ്രവർത്തനം.

void av_create_and_push(AV **const avp,
SV * കോൺസ്റ്റ് മൂല്യം)

av_create_and_unshift_one
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

അറേയുടെ തുടക്കത്തിലേക്ക് ഒരു SV അൺഷിഫ്റ്റ് ചെയ്യുന്നു, ആവശ്യമെങ്കിൽ അറേ സൃഷ്ടിക്കുന്നു.
സാധാരണയായി ഡ്യൂപ്ലിക്കേറ്റഡ് ഐഡിയം നീക്കം ചെയ്യുന്നതിനുള്ള ഒരു ചെറിയ ആന്തരിക സഹായ പ്രവർത്തനം.

SV** av_create_and_unshift_one(AV **const avp,
SV * കോൺസ്റ്റ് മൂല്യം)

av_delete
അറേയിൽ നിന്ന് "കീ" ഉപയോഗിച്ച് സൂചികയിലാക്കിയ ഘടകത്തെ ഇല്ലാതാക്കുന്നു, മൂലകത്തെ മാരകമാക്കുന്നു, കൂടാതെ
അത് തിരികെ നൽകുന്നു. "ഫ്ലാഗുകൾ" "G_DISCARD" ന് തുല്യമാണെങ്കിൽ, മൂലകം സ്വതന്ത്രമാവുകയും അസാധുവാകുകയും ചെയ്യും
മടങ്ങി. പേൾ തുല്യമായത്: "എന്റെ $elem = ഇല്ലാതാക്കുക($myarray[$idx]);" വേണ്ടി
"G_DISCARD" അല്ലാത്ത പതിപ്പും ഒരു അസാധുവായ സന്ദർഭവും "ഇല്ലാതാക്കുക($myarray[$idx]);" വേണ്ടി
"G_DISCARD" പതിപ്പ്.

SV* av_delete(AV *av, SSize_t കീ, I32 ഫ്ലാഗുകൾ)

av_ നിലവിലുണ്ട്
"കീ" ഇൻഡക്‌സ് ചെയ്‌ത ഘടകം ആരംഭിച്ചിട്ടുണ്ടെങ്കിൽ ശരി നൽകുന്നു.

ഇത് ആരംഭിക്കാത്ത അറേ ഘടകങ്ങൾ NULL ആയി സജ്ജീകരിച്ചിരിക്കുന്നു എന്ന വസ്തുതയെ ആശ്രയിച്ചിരിക്കുന്നു.

പേൾ തുല്യമായത്: "നിലവിലുണ്ട്($myarray[$key])".

bool av_exist(AV *av, SSize_t കീ)

av_extend
ഒരു അറേ മുൻകൂട്ടി നീട്ടുക. "കീ" എന്നത് അറേ ആയിരിക്കേണ്ട സൂചികയാണ്
നീട്ടി.

void av_extend(AV *av, SSize_t കീ)

av_fetch
അറേയിലെ നിർദ്ദിഷ്ട സൂചികയിൽ SV നൽകുന്നു. "കീ" എന്നത് സൂചികയാണ്. എങ്കിൽ
lval എന്നത് ശരിയാണ്, നിങ്ങൾക്ക് ഒരു യഥാർത്ഥ SV തിരികെ ലഭിക്കുമെന്ന് ഉറപ്പുനൽകുന്നു (അത് യഥാർത്ഥമല്ലെങ്കിൽ
മുമ്പ്), അത് നിങ്ങൾക്ക് പരിഷ്കരിക്കാനാകും. റിട്ടേൺ മൂല്യം അസാധുവാണോ എന്ന് പരിശോധിക്കുക
ഒരു "SV*" ലേക്ക് മാറ്റുന്നതിന് മുമ്പ്.

കൂടുതൽ അറിയാൻ പെർൾഗട്ടിലെ "അണ്ടർസ്റ്റാൻഡിംഗ് ദി മാജിക് ഓഫ് ടൈഡ് ഹാഷുകളുടെയും അറേകളുടെയും" കാണുക
ടൈഡ് അറേകളിൽ ഈ ഫംഗ്‌ഷൻ എങ്ങനെ ഉപയോഗിക്കാം എന്നതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ.

$myarray[$idx] ആണ് പരുക്കൻ പെർലിന് തുല്യമായത്.

SV** av_fetch(AV *av, SSize_t കീ, I32 lval)

av_fill അറേയിലെ ഏറ്റവും ഉയർന്ന സൂചിക, തന്നിരിക്കുന്ന നമ്പറിലേക്ക് സജ്ജീകരിക്കുക, ഇത് Perl-ന് തുല്യമാണ്
"$#array = $fill;".

അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം "ഫിൽ + 1" എന്നതിന് ശേഷം ആയിരിക്കും av_fill() തിരികെ വരുത്തുന്നു.
അറേ മുമ്പ് ചെറുതായിരുന്നെങ്കിൽ, അനുബന്ധ ഘടകങ്ങൾ സജ്ജീകരിച്ചിരിക്കുന്നു
NULL ലേക്ക്. അറേ ദൈർഘ്യമേറിയതാണെങ്കിൽ, അധിക ഘടകങ്ങൾ സ്വതന്ത്രമാക്കും.
"av_fill(av, -1)" എന്നത് "av_clear(av)" എന്നതിന് സമാനമാണ്.

void av_fill(AV *av, SSize_t പൂരിപ്പിക്കൽ)

av_len "av_top_index" പോലെ തന്നെ. പേര് സൂചിപ്പിക്കുന്നതിൽ നിന്ന് വ്യത്യസ്തമായി, അത് തിരികെ നൽകുന്നു എന്നത് ശ്രദ്ധിക്കുക
അറേയിലെ ഏറ്റവും ഉയർന്ന സൂചിക, അതിനാൽ നിങ്ങൾ ഉപയോഗിക്കേണ്ട അറേയുടെ വലുപ്പം ലഭിക്കാൻ
"av_len(av) + 1". ഇത് "sv_len" പോലെയല്ല, നിങ്ങൾ പ്രതീക്ഷിക്കുന്നത് തിരികെ നൽകുന്നു.

SSize_t av_len(AV *av)

av_make ഒരു പുതിയ AV സൃഷ്‌ടിക്കുകയും അത് SV-കളുടെ ഒരു ലിസ്റ്റ് ഉപയോഗിച്ച് പോപ്പുലേറ്റ് ചെയ്യുകയും ചെയ്യുന്നു. എസ്വികൾ ഇതിലേക്ക് പകർത്തിയിരിക്കുന്നു
അറേ, അതിനാൽ av_make-ലേക്കുള്ള കോളിന് ശേഷം അവർ മോചിതരായേക്കാം. പുതിയ AV യിൽ ഒരു ഉണ്ടായിരിക്കും
റഫറൻസ് എണ്ണം 1.

പേൾ തുല്യമായത്: "my @new_array = ($scalar1, $scalar2, $scalar3...);"

AV* av_make(SSize_t വലുപ്പം, SV **strp)

av_pop അറേയുടെ അറ്റത്ത് നിന്ന് ഒരു SV നീക്കംചെയ്യുന്നു, അതിന്റെ വലുപ്പം ഒന്നായി കുറയ്ക്കുകയും മടങ്ങുകയും ചെയ്യുന്നു
SV (ഒരു റഫറൻസ് എണ്ണത്തിന്റെ നിയന്ത്രണം കൈമാറ്റം ചെയ്യുന്നു) വിളിക്കുന്നയാൾക്ക്. മടങ്ങുന്നു
അറേ ശൂന്യമാണെങ്കിൽ &PL_sv_undef.

പേൾ തുല്യമായത്: "pop(@myarray);"

SV* av_pop(AV *av)

av_push ഒരു SV അറേയുടെ അറ്റത്തേക്ക് തള്ളുന്നു. അറേ സ്വയമേവ വളരും
കൂട്ടിച്ചേർക്കൽ ഉൾക്കൊള്ളുക. ഇത് ഒരു റഫറൻസ് എണ്ണത്തിന്റെ ഉടമസ്ഥാവകാശം എടുക്കുന്നു.

പേളിന് തുല്യമായത്: "push @myarray, $elem;".

void av_push(AV *av, SV *val)

av_shift
അറേയുടെ ആരംഭത്തിൽ നിന്ന് ഒരു SV നീക്കം ചെയ്യുന്നു, അതിന്റെ വലുപ്പം ഒന്നായി കുറയ്ക്കുകയും മടങ്ങുകയും ചെയ്യുന്നു
SV (ഒരു റഫറൻസ് എണ്ണത്തിന്റെ നിയന്ത്രണം കൈമാറ്റം ചെയ്യുന്നു) വിളിക്കുന്നയാൾക്ക്. മടങ്ങുന്നു
അറേ ശൂന്യമാണെങ്കിൽ &PL_sv_undef.

പേൾ തത്തുല്യം: "ഷിഫ്റ്റ്(@myarray);"

SV* av_shift(AV *av)

av_സ്റ്റോർ
ഒരു അറേയിൽ ഒരു SV സംഭരിക്കുന്നു. അറേ സൂചിക "കീ" എന്ന് വ്യക്തമാക്കിയിരിക്കുന്നു. തിരിച്ചുവരവ്
പ്രവർത്തനം പരാജയപ്പെട്ടാൽ അല്ലെങ്കിൽ മൂല്യം ആവശ്യമില്ലെങ്കിൽ മൂല്യം NULL ആയിരിക്കും
യഥാർത്ഥത്തിൽ അറേയ്‌ക്കുള്ളിൽ സംഭരിച്ചിരിക്കുന്നു (ടൈഡ് അറേകളുടെ കാര്യത്തിലെന്നപോലെ). അല്ലെങ്കിൽ, അത്
അവിടെ സംഭരിച്ചിരിക്കുന്ന "SV*" (= "val")) ലഭിക്കുന്നതിന് dereference ചെയ്യാം.

റഫറൻസ് എണ്ണം ഉചിതമായി വർദ്ധിപ്പിക്കുന്നതിന് കോളർ ഉത്തരവാദിയാണെന്ന് ശ്രദ്ധിക്കുക
കോളിന് മുമ്പുള്ള "val", കൂടാതെ ഫംഗ്‌ഷൻ NULL നൽകുകയാണെങ്കിൽ അത് കുറയ്ക്കുന്നു.

ഏകദേശ പേൾ തത്തുല്യം: "$myarray[$key] = $val;".

കൂടുതൽ അറിയാൻ പെർൾഗട്ടിലെ "അണ്ടർസ്റ്റാൻഡിംഗ് ദി മാജിക് ഓഫ് ടൈഡ് ഹാഷുകളുടെയും അറേകളുടെയും" കാണുക
ടൈഡ് അറേകളിൽ ഈ ഫംഗ്‌ഷൻ എങ്ങനെ ഉപയോഗിക്കാം എന്നതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ.

SV** av_store(AV *av, SSize_t കീ, SV *val)

av_tindex
"av_top_index()" പോലെ തന്നെ.

int av_tindex(AV* av)

av_top_index
അറേയിലെ ഏറ്റവും ഉയർന്ന സൂചിക നൽകുന്നു. അറേയിലെ മൂലകങ്ങളുടെ എണ്ണം
"av_top_index(av) + 1". അറേ ശൂന്യമാണെങ്കിൽ -1 നൽകുന്നു.

ഇതിന് തുല്യമായ പേൾ $#myarray ആണ്.

(അല്പം ചെറിയ രൂപം "av_tindex" ആണ്.)

SSize_t av_top_index(AV *av)

av_undef
അറേ നിർവചിക്കാതിരിക്കുന്നു. "undef(@array)" എന്നതിന് തുല്യമായ XS.

അറേയുടെ എല്ലാ ഘടകങ്ങളും സ്വതന്ത്രമാക്കുന്നതിനൊപ്പം ("av_clear()" പോലെ), ഇതും
സ്കെയിലറുകളുടെ ലിസ്റ്റ് സംഭരിക്കുന്നതിന് av ഉപയോഗിക്കുന്ന മെമ്മറി സ്വതന്ത്രമാക്കുന്നു.

റിട്ടേണിൽ അസാധുവാകാൻ സാധ്യതയുള്ള അറേയെ കുറിച്ചുള്ള കുറിപ്പിനായി "av_clear" കാണുക.

അസാധുവായ av_undef(AV *av)

av_unshift
നൽകിയിരിക്കുന്ന "undef" മൂല്യങ്ങളുടെ എണ്ണം അറേയുടെ തുടക്കത്തിലേക്ക് മാറ്റുക. ദി
കൂട്ടിച്ചേർക്കൽ ഉൾക്കൊള്ളാൻ അറേ സ്വയമേവ വളരും. അപ്പോൾ നിങ്ങൾ ഉപയോഗിക്കണം
ഈ പുതിയ ഘടകങ്ങൾക്ക് മൂല്യങ്ങൾ നൽകുന്നതിന് "av_store".

പേൾ തുല്യമായത്: "unshift @myarray, ((undef) x $n );"

void av_unshift(AV *av, SSize_t സംഖ്യ)

get_av നിർദ്ദിഷ്‌ട പേൾ ഗ്ലോബൽ അല്ലെങ്കിൽ പാക്കേജ് അറേയുടെ എവി നൽകുന്നു
(അതിനാൽ ഇത് ലെക്സിക്കൽ വേരിയബിളുകളിൽ പ്രവർത്തിക്കില്ല). "ഫ്ലാഗുകൾ" "gv_fetchpv" ലേക്ക് കൈമാറുന്നു. എങ്കിൽ
"GV_ADD" സജ്ജമാക്കി, Perl വേരിയബിൾ നിലവിലില്ല, തുടർന്ന് അത് സൃഷ്ടിക്കപ്പെടും. എങ്കിൽ
"flags" പൂജ്യമാണ്, വേരിയബിൾ നിലവിലില്ല, തുടർന്ന് NULL തിരികെ നൽകും.

പേളിന് തുല്യമായത്: "@{"$name"}".

ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷന്റെ perl_ ഫോം ഒഴിവാക്കിയിരിക്കുന്നു.

AV* get_av(const char *name, I32 ഫ്ലാഗുകൾ)

newAV ഒരു പുതിയ AV സൃഷ്ടിക്കുന്നു. റഫറൻസ് എണ്ണം 1 ആയി സജ്ജീകരിച്ചിരിക്കുന്നു.

പേൾ തുല്യമായത്: "my @array;".

AV* newAV()

sortsv ഒരു അറേ അടുക്കുക. ഒരു ഉദാഹരണം ഇതാ:

sortsv(AvARRAY(av), av_top_index(av)+1, Perl_sv_cmp_locale);

നിലവിൽ ഇത് എല്ലായ്പ്പോഴും മെർജസോർട്ട് ഉപയോഗിക്കുന്നു. കൂടുതൽ വഴക്കമുള്ളതിനായി sortsv_flags കാണുക
ദിനചര്യ.

void sortsv(SV** array, size_t num_elts,
SVCOMPARE_t cmp)

sortsv_flags
വിവിധ ഓപ്‌ഷനുകൾക്കൊപ്പം ഒരു അറേ അടുക്കുക.

void sortsv_flags(SV** array, size_t num_elts,
SVCOMPARE_t cmp, U32 ഫ്ലാഗുകൾ)

"xsubpp" വേരിയബിളുകൾ ഒപ്പം ആന്തരിക ഫംഗ്ഷനുകളും

ഉപയോഗിക്കുന്ന സ്റ്റാക്ക് ബേസ് ഓഫ്‌സെറ്റ് സൂചിപ്പിക്കാൻ "xsubpp" സജ്ജീകരിച്ച ax വേരിയബിൾ
"ST", "XSprePUSH", "XSRETURN" മാക്രോകൾ. "dMARK" മാക്രോയെ മുൻകൂട്ടി വിളിക്കണം
"മാർക്ക്" വേരിയബിൾ സജ്ജീകരിക്കാൻ.

I32 കോടാലി

ഒരു C++ XS-നുള്ള ക്ലാസ് നാമം സൂചിപ്പിക്കാൻ "xsubpp" സജ്ജീകരിച്ചിരിക്കുന്ന CLASS വേരിയബിൾ
കൺസ്ട്രക്റ്റർ. ഇത് എല്ലായ്പ്പോഴും ഒരു "ചാര്*" ആണ്. "ഇത്" കാണുക.

ചാർ* ക്ലാസ്

dAX "ax" വേരിയബിൾ സജ്ജമാക്കുന്നു. ഇത് സാധാരണയായി "xsubpp" വഴി സ്വയമേവ കൈകാര്യം ചെയ്യുന്നു
"dXSARGS" എന്ന് വിളിക്കുന്നു.

dAX;

dAXMARK "ax" വേരിയബിളും സ്റ്റാക്ക് മാർക്കർ വേരിയബിളും "mark" സജ്ജമാക്കുന്നു. ഇത് സാധാരണയാണ്
"dXSARGS" എന്ന് വിളിച്ച് "xsubpp" സ്വയമേവ കൈകാര്യം ചെയ്യുന്നു.

dAXMARK;

dITEMS "ഇനങ്ങൾ" വേരിയബിൾ സജ്ജീകരിക്കുന്നു. ഇത് സാധാരണയായി "xsubpp" സ്വയമേവ കൈകാര്യം ചെയ്യുന്നു
"dXSARGS" എന്ന് വിളിക്കുന്നതിലൂടെ.

dITEMS;

ഡണ്ടർബാർ
"UNDERBAR" മാക്രോയ്ക്ക് ആവശ്യമായ ഏത് വേരിയബിളും സജ്ജീകരിക്കുന്നു. അത് നിർവചിക്കാൻ ഉപയോഗിച്ചു
"padoff_du", എന്നാൽ ഇത് നിലവിൽ ഒരു നൂപ് ആണ്. എന്നിരുന്നാലും, ഇപ്പോഴും തുടരാൻ ശക്തമായി ഉപദേശിക്കുന്നു
ഭൂതകാലവും ഭാവിയും അനുയോജ്യത ഉറപ്പാക്കാൻ ഇത് ഉപയോഗിക്കുക.

ഡണ്ടർബാർ;

dXSARGS, dSP, dMARK എന്നിവയെ വിളിച്ച് ഒരു XSUB-നായി സ്റ്റാക്ക്, മാർക്ക് പോയിന്ററുകൾ സജ്ജീകരിക്കുന്നു. സജ്ജമാക്കുന്നു
"dAX", "dITEMS" എന്നിവ വിളിച്ച് "ax", "items" വേരിയബിളുകൾ. ഇത് സാധാരണയായി കൈകാര്യം ചെയ്യുന്നു
"xsubpp" വഴി സ്വയമേവ.

dXSARGS;

dXSI32 അപരനാമങ്ങളുള്ള ഒരു XSUB-നായി "ix" വേരിയബിൾ സജ്ജീകരിക്കുന്നു. ഇത് സാധാരണയായി കൈകാര്യം ചെയ്യുന്നു
"xsubpp" വഴി സ്വയമേവ.

dXSI32;

സ്റ്റാക്കിലെ ഇനങ്ങളുടെ എണ്ണം സൂചിപ്പിക്കാൻ "xsubpp" സജ്ജീകരിച്ചിരിക്കുന്ന ഇനങ്ങൾ വേരിയബിൾ.
perlxs-ൽ "വേരിയബിൾ-ലെംഗ്ത്ത് പാരാമീറ്റർ ലിസ്റ്റുകൾ" കാണുക.

I32 ഇനങ്ങൾ

XSUB-ന്റെ അപരനാമങ്ങളിൽ ഏതാണെന്ന് സൂചിപ്പിക്കാൻ "xsubpp" സജ്ജീകരിച്ചിരിക്കുന്ന വേരിയബിൾ
അത് വിളിക്കാൻ ഉപയോഗിച്ചു. perlxs-ൽ "The ALIAS: Keyword" കാണുക.

I32 ix

ഒരു XSUB-നുള്ള റിട്ടേൺ മൂല്യം നിലനിർത്താൻ "xsubpp" സജ്ജീകരിച്ച റിറ്റിവൽ വേരിയബിൾ. ഇതാണ്
XSUB-ന് എപ്പോഴും ശരിയായ തരം. perlxs-ൽ "RETVAL വേരിയബിൾ" കാണുക.

(എന്തായാലും) റിറ്റിവൽ

XSUB ന്റെ സ്റ്റാക്കിലെ ഘടകങ്ങൾ ആക്‌സസ് ചെയ്യാൻ ST ഉപയോഗിക്കുന്നു.

SV* ST(int ix)

ഒരു C++ XSUB-ൽ ഒബ്‌ജക്‌റ്റിനെ നിയോഗിക്കുന്നതിന് "xsubpp" സജ്ജീകരിച്ചിരിക്കുന്ന ഈ വേരിയബിൾ. ഈ
C++ ഒബ്‌ജക്റ്റിന് എപ്പോഴും അനുയോജ്യമായ തരം. "ക്ലാസ്", "സി++ ഉപയോഗിച്ച് XS ഉപയോഗിക്കൽ" എന്നിവ കാണുക
perlxs ൽ.

(എന്തായാലും) ഇത്

അണ്ടർബാർ
$_ വേരിയബിളുമായി ബന്ധപ്പെട്ട SV*. ഒരു ലെക്സിക്കൽ $_ ഇൻ ഉണ്ടെങ്കിലും പ്രവർത്തിക്കുന്നു
ഭാവിയുളള.

ഒരു XSUB-ഉം അതിന്റെ C പാരാമീറ്റർ ലിസ്റ്റും പ്രഖ്യാപിക്കാൻ XS മാക്രോ. ഇത് കൈകാര്യം ചെയ്യുന്നത് "xsubpp" ആണ്.
ഇത് കൂടുതൽ വ്യക്തമായ XS_EXTERNAL മാക്രോ ഉപയോഗിക്കുന്നതിന് സമാനമാണ്.

XS_EXTERNAL
ഒരു XSUB പ്രഖ്യാപിക്കാൻ മാക്രോയും അതിന്റെ C പാരാമീറ്റർ ലിസ്റ്റും വ്യക്തമായി കയറ്റുമതി ചെയ്യുന്നു
ചിഹ്നങ്ങൾ.

XS_INTERNAL
ചിഹ്നങ്ങൾ കയറ്റുമതി ചെയ്യാതെ തന്നെ ഒരു XSUB-ഉം അതിന്റെ C പാരാമീറ്റർ ലിസ്റ്റും പ്രഖ്യാപിക്കാൻ മാക്രോ.
ഇത് കൈകാര്യം ചെയ്യുന്നത് "xsubpp" ആണ്, XSUB കയറ്റുമതി ചെയ്യുന്നതിനേക്കാൾ പൊതുവെ അഭികാമ്യമാണ്
അനാവശ്യമായി ചിഹ്നങ്ങൾ.

തിരിച്ചുവിളിക്കുക പ്രവർത്തനങ്ങൾ

call_argv
നിർദ്ദിഷ്‌ട പേരുള്ളതും പാക്കേജ്-സ്കോപ്പ് ചെയ്‌തതുമായ പേൾ സബ്‌റൂട്ടീനിലേക്ക് ഒരു കോൾബാക്ക് നടത്തുന്നു
ആർഗ്യുമെന്റുകളായി "argv" (ഒരു NULL-ടെർമിനേറ്റഡ് സ്ട്രിംഗുകൾ). perlcall കാണുക.

ഏകദേശ പേൾ തത്തുല്യം: "&{"$sub_name"}(@$argv)".

ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷന്റെ perl_ ഫോം ഒഴിവാക്കിയിരിക്കുന്നു.

I32 call_argv(const char* sub_name, I32 ഫ്ലാഗുകൾ,
char** argv)

കോൾ_രീതി
നിർദ്ദിഷ്‌ട പേൾ രീതിയിലേക്ക് ഒരു കോൾബാക്ക് നടത്തുന്നു. അനുഗ്രഹിക്കപ്പെട്ട വസ്തു ഓണായിരിക്കണം
സ്റ്റാക്ക്. perlcall കാണുക.

ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷന്റെ perl_ ഫോം ഒഴിവാക്കിയിരിക്കുന്നു.

I32 call_method(const char* methname, I32 ഫ്ലാഗുകൾ)

call_pv നിർദ്ദിഷ്‌ട Perl ഉപയിലേക്ക് ഒരു കോൾബാക്ക് നടത്തുന്നു. perlcall കാണുക.

ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷന്റെ perl_ ഫോം ഒഴിവാക്കിയിരിക്കുന്നു.

I32 call_pv(const char* sub_name, I32 ഫ്ലാഗുകൾ)

call_sv SV വ്യക്തമാക്കിയ Perl ഉപയിലേക്ക് ഒരു കോൾബാക്ക് നടത്തുന്നു.

"G_METHOD" അല്ലെങ്കിൽ "G_METHOD_NAMED" ഫ്ലാഗ് വിതരണം ചെയ്തിട്ടില്ലെങ്കിൽ, എസ്.വി.
ഒരു CV, ഒരു GV, ഒരു CV-യിലേക്കുള്ള ഒരു റഫറൻസ്, ഒരു GV അല്ലെങ്കിൽ "SvPV(sv)" എന്നിവയിലേക്കുള്ള ഒരു റഫറൻസ് ഉപയോഗിക്കും.
വിളിക്കേണ്ട ഉപയുടെ പേര്.

"G_METHOD" ഫ്ലാഗ് നൽകിയിട്ടുണ്ടെങ്കിൽ, SV ഒരു CV-യെ അല്ലെങ്കിൽ
വിളിക്കാനുള്ള രീതിയുടെ പേരായി "SvPV(sv)" ഉപയോഗിക്കും.

"G_METHOD_NAMED" ഫ്ലാഗ് നൽകിയിട്ടുണ്ടെങ്കിൽ, "SvPV(sv)" എന്നത് ഇതിന്റെ പേരായി ഉപയോഗിക്കും
വിളിക്കാനുള്ള രീതി.

മറ്റ് ചില മൂല്യങ്ങൾ ആന്തരിക ഉപയോഗത്തിനായി പ്രത്യേകം പരിഗണിക്കപ്പെടുന്നു, അവ പാടില്ല
ആശ്രയിച്ചു.

perlcall കാണുക.

ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷന്റെ perl_ ഫോം ഒഴിവാക്കിയിരിക്കുന്നു.

I32 call_sv(SV* sv, VOL I32 ഫ്ലാഗുകൾ)

ഒരു കോൾബാക്കിൽ തുറക്കുന്ന ബ്രാക്കറ്റ് നൽകുക. "വിടുക" കാണുക, perlcall ചെയ്യുക.

പ്രവേശിക്കുക;

eval_pv സ്കെയിലർ സന്ദർഭത്തിൽ തന്നിരിക്കുന്ന സ്ട്രിംഗ് "eval" ചെയ്യാനും ഒരു SV* ഫലം നൽകാനും Perl-നോട് പറയുന്നു.

ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷന്റെ perl_ ഫോം ഒഴിവാക്കിയിരിക്കുന്നു.

SV* eval_pv(const char* p, I32 croak_on_error)

eval_sv SV-യിലെ സ്ട്രിംഗ് "eval" ചെയ്യാൻ Perl-നോട് പറയുന്നു. ഇത് അതേ പതാകകളെ പിന്തുണയ്ക്കുന്നു
"call_sv", G_EVAL ഒഴികെ. perlcall കാണുക.

ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷന്റെ perl_ ഫോം ഒഴിവാക്കിയിരിക്കുന്നു.

I32 eval_sv(SV* sv, I32 ഫ്ലാഗുകൾ)

ഫ്രീഎംപിഎസ്
ഒരു കോൾബാക്കിൽ താൽക്കാലികക്കാർക്കുള്ള ക്ലോസിംഗ് ബ്രാക്കറ്റ്. "SAVETMPS" കാണുക, perlcall.

ഫ്രീഎംപിഎസ്;

ഒരു കോൾബാക്കിൽ ക്ലോസിംഗ് ബ്രാക്കറ്റ് വിടുക. "ENTER" കാണുക, perlcall ചെയ്യുക.

വിട്ടേക്കുക;

സേവ്ഇഎംപിഎസ്
ഒരു കോൾബാക്കിൽ താൽക്കാലികക്കാർക്കുള്ള ബ്രാക്കറ്റ് തുറക്കുന്നു. "FREETMPS" കാണുക, perlcall.

SAVETMPS;

കഥാപാത്രം കേസ് മാറ്റുന്നതിൽ

toFOLD നിർദ്ദിഷ്ട പ്രതീകത്തെ ഫോൾഡ്കേസിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു. ഇൻപുട്ട് എന്തെങ്കിലും ആണെങ്കിൽ
ASCII വലിയക്ഷരം, ആ ഇൻപുട്ട് പ്രതീകം തന്നെ തിരികെ നൽകുന്നു. വേരിയന്റ്
"toFOLD_A" എന്നത് തുല്യമാണ്. (പൂർണ്ണമായതിന് തുല്യമായ "to_FOLD_L1" ഇല്ല
Latin1 ശ്രേണി, അവിടെ "toFOLD_uni" എന്നതിന്റെ പൂർണ്ണമായ സാമാന്യത ആവശ്യമാണ്.)

U8 to FOLD(U8 ch)

FOLD_uni വരെ
യൂണിക്കോഡ് കോഡ് പോയിന്റ് "cp" അതിന്റെ ഫോൾഡ്കേസ് പതിപ്പിലേക്ക് പരിവർത്തനം ചെയ്യുകയും അതിൽ സംഭരിക്കുകയും ചെയ്യുന്നു
"s"-ൽ UTF-8, "lenp"-ൽ അതിന്റെ നീളം ബൈറ്റുകളിൽ. ബഫർ ചൂണ്ടിക്കാണിച്ചത് ശ്രദ്ധിക്കുക
"s" വഴി ഫോൾഡ്‌കേസ് മുതൽ കുറഞ്ഞത് "UTF8_MAXBYTES_CASE+1" ബൈറ്റുകൾ ആയിരിക്കണം
പതിപ്പ് യഥാർത്ഥ പ്രതീകത്തേക്കാൾ ദൈർഘ്യമേറിയതായിരിക്കാം.

ഫോൾഡ്‌കേസ് ചെയ്‌ത പതിപ്പിന്റെ ആദ്യ കോഡ് പോയിന്റ് തിരികെ ലഭിച്ചു (എന്നാൽ വിശദീകരിച്ചതുപോലെ ശ്രദ്ധിക്കുക
തൊട്ടു മുകളിൽ, കൂടുതൽ ഉണ്ടായേക്കാം.)

UV toFOLD_uni(UV cp, U8* s, STRLEN* lenp)

toFOLD_utf8
"p"-ൽ UTF-8 എൻകോഡ് ചെയ്ത പ്രതീകത്തെ അതിന്റെ ഫോൾഡ്കേസ് പതിപ്പിലേക്ക് പരിവർത്തനം ചെയ്യുകയും സംഭരിക്കുകയും ചെയ്യുന്നു
UTF-8 ൽ "s" ലും അതിന്റെ ദൈർഘ്യം "lenp" ൽ ബൈറ്റിലും. ബഫർ എന്നത് ശ്രദ്ധിക്കുക
"s" ചൂണ്ടിക്കാണിക്കുന്നത് മുതൽ കുറഞ്ഞത് "UTF8_MAXBYTES_CASE+1" ബൈറ്റുകൾ ആയിരിക്കണം
ഫോൾഡ്കേസ് പതിപ്പ് യഥാർത്ഥ പ്രതീകത്തേക്കാൾ ദൈർഘ്യമേറിയതായിരിക്കാം.

ഫോൾഡ്‌കേസ് ചെയ്‌ത പതിപ്പിന്റെ ആദ്യ കോഡ് പോയിന്റ് തിരികെ ലഭിച്ചു (എന്നാൽ വിശദീകരിച്ചതുപോലെ ശ്രദ്ധിക്കുക
തൊട്ടു മുകളിൽ, കൂടുതൽ ഉണ്ടായേക്കാം.)

"p" എന്നതിലെ ഇൻപുട്ട് പ്രതീകം നന്നായി രൂപപ്പെടുത്തിയതായി അനുമാനിക്കപ്പെടുന്നു.

UV toFOLD_utf8(U8* p, U8* s, STRLEN* lenp)

toLOWER നിർദ്ദിഷ്ട പ്രതീകത്തെ ചെറിയക്ഷരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു. ഇൻപുട്ട് എന്തെങ്കിലും ആണെങ്കിൽ
ASCII വലിയക്ഷരം, ആ ഇൻപുട്ട് പ്രതീകം തന്നെ തിരികെ നൽകുന്നു. വേരിയന്റ്
"toLOWER_A" എന്നത് തുല്യമാണ്.

U8 മുതൽ താഴെ വരെ(U8 ch)

LOWER_L1 വരെ
നിർദ്ദിഷ്‌ട ലാറ്റിൻ1 പ്രതീകം ചെറിയക്ഷരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു. ഫലങ്ങൾ നിർവചിക്കപ്പെട്ടിട്ടില്ല
ഇൻപുട്ട് ഒരു ബൈറ്റിൽ ചേരുന്നില്ലെങ്കിൽ.

U8 മുതൽLOWER_L1(U8 ch)

LOWER_LC വരെ
നിലവിലെ പ്രാദേശിക നിയമങ്ങൾ ഉപയോഗിച്ച് നിർദ്ദിഷ്ട പ്രതീകത്തെ ചെറിയക്ഷരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു, എങ്കിൽ
സാധ്യമാണ്; അല്ലെങ്കിൽ ഇൻപുട്ട് പ്രതീകം തന്നെ നൽകുന്നു.

U8 മുതൽLOWER_LC(U8 ch)

LOWER_uni വരെ
യൂണികോഡ് കോഡ് പോയിന്റ് "cp" അതിന്റെ ചെറിയക്ഷര പതിപ്പിലേക്ക് പരിവർത്തനം ചെയ്യുകയും അതിൽ സംഭരിക്കുകയും ചെയ്യുന്നു
"s"-ൽ UTF-8, "lenp"-ൽ അതിന്റെ നീളം ബൈറ്റുകളിൽ. ബഫർ ചൂണ്ടിക്കാണിച്ചത് ശ്രദ്ധിക്കുക
"s" വഴി ചെറിയക്ഷരം മുതൽ കുറഞ്ഞത് "UTF8_MAXBYTES_CASE+1" ബൈറ്റുകൾ ആയിരിക്കണം
പതിപ്പ് യഥാർത്ഥ പ്രതീകത്തേക്കാൾ ദൈർഘ്യമേറിയതായിരിക്കാം.

ചെറിയക്ഷരത്തിലുള്ള പതിപ്പിന്റെ ആദ്യ കോഡ് പോയിന്റ് തിരികെ ലഭിച്ചു (എന്നാൽ, വിശദീകരിച്ചതുപോലെ ശ്രദ്ധിക്കുക
തൊട്ടു മുകളിൽ, കൂടുതൽ ഉണ്ടായേക്കാം.)

UV മുതൽLOWER_uni(UV cp, U8* s, STRLEN* lenp)

ലേക്ക്LOWER_utf8
"p"-ൽ UTF-8 എൻകോഡ് ചെയ്ത പ്രതീകത്തെ അതിന്റെ ചെറിയക്ഷര പതിപ്പിലേക്ക് പരിവർത്തനം ചെയ്യുകയും സംഭരിക്കുകയും ചെയ്യുന്നു
UTF-8 ൽ "s" ലും അതിന്റെ ദൈർഘ്യം "lenp" ൽ ബൈറ്റിലും. ബഫർ എന്നത് ശ്രദ്ധിക്കുക
"s" ചൂണ്ടിക്കാണിക്കുന്നത് മുതൽ കുറഞ്ഞത് "UTF8_MAXBYTES_CASE+1" ബൈറ്റുകൾ ആയിരിക്കണം
ചെറിയക്ഷര പതിപ്പ് യഥാർത്ഥ പ്രതീകത്തേക്കാൾ ദൈർഘ്യമേറിയതായിരിക്കാം.

ചെറിയക്ഷരത്തിലുള്ള പതിപ്പിന്റെ ആദ്യ കോഡ് പോയിന്റ് തിരികെ ലഭിച്ചു (എന്നാൽ, വിശദീകരിച്ചതുപോലെ ശ്രദ്ധിക്കുക
തൊട്ടു മുകളിൽ, കൂടുതൽ ഉണ്ടായേക്കാം.)

"p" എന്നതിലെ ഇൻപുട്ട് പ്രതീകം നന്നായി രൂപപ്പെടുത്തിയതായി അനുമാനിക്കപ്പെടുന്നു.

UV toLOWER_utf8(U8* p, U8* s, STRLEN* lenp)

toTITLE നിർദ്ദിഷ്ട പ്രതീകത്തെ ടൈറ്റിൽകേസിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു. ഇൻപുട്ട് എന്തെങ്കിലും ആണെങ്കിൽ
ASCII ചെറിയക്ഷരം, ആ ഇൻപുട്ട് പ്രതീകം തന്നെ തിരികെ നൽകുന്നു. വേരിയന്റ്
"toTITLE_A" എന്നത് തുല്യമാണ്. (പൂർണ്ണമായ ലാറ്റിൻ1 ശ്രേണിക്ക് "toTITLE_L1" ഇല്ല,
"toTITLE_uni" എന്നതിന്റെ പൂർണ്ണമായ സാമാന്യത അവിടെ ആവശ്യമായതിനാൽ. തലക്കെട്ട് ഒരു അല്ല
ലോക്കൽ ഹാൻഡ്‌ലിംഗിൽ ഉപയോഗിക്കുന്ന ആശയം, അതിനാൽ അതിനുള്ള പ്രവർത്തനങ്ങളൊന്നുമില്ല.)

U8 മുതൽ TITLE(U8 ch)

TITLE_uni
യൂണികോഡ് കോഡ് പോയിന്റ് "cp" അതിന്റെ ടൈറ്റിൽകേസ് പതിപ്പിലേക്ക് പരിവർത്തനം ചെയ്യുകയും അതിൽ സംഭരിക്കുകയും ചെയ്യുന്നു
"s"-ൽ UTF-8, "lenp"-ൽ അതിന്റെ നീളം ബൈറ്റുകളിൽ. ബഫർ ചൂണ്ടിക്കാണിച്ചത് ശ്രദ്ധിക്കുക
ടൈറ്റിൽകേസ് മുതൽ "s" വഴി കുറഞ്ഞത് "UTF8_MAXBYTES_CASE+1" ബൈറ്റുകൾ വേണം
പതിപ്പ് യഥാർത്ഥ പ്രതീകത്തേക്കാൾ ദൈർഘ്യമേറിയതായിരിക്കാം.

ടൈറ്റിൽകേസ് ചെയ്‌ത പതിപ്പിന്റെ ആദ്യ കോഡ് പോയിന്റ് തിരികെ ലഭിച്ചു (എന്നാൽ വിശദീകരിച്ചതുപോലെ ശ്രദ്ധിക്കുക
തൊട്ടു മുകളിൽ, കൂടുതൽ ഉണ്ടായേക്കാം.)

UV toTITLE_uni(UV cp, U8* s, STRLEN* lenp)

toTITLE_utf8
"p"-ൽ UTF-8 എൻകോഡ് ചെയ്ത പ്രതീകത്തെ അതിന്റെ ടൈറ്റിൽകേസ് പതിപ്പിലേക്ക് പരിവർത്തനം ചെയ്യുകയും സംഭരിക്കുകയും ചെയ്യുന്നു
UTF-8 ൽ "s" ലും അതിന്റെ ദൈർഘ്യം "lenp" ൽ ബൈറ്റിലും. ബഫർ എന്നത് ശ്രദ്ധിക്കുക
"s" ചൂണ്ടിക്കാണിക്കുന്നത് മുതൽ കുറഞ്ഞത് "UTF8_MAXBYTES_CASE+1" ബൈറ്റുകൾ ആയിരിക്കണം
ടൈറ്റിൽകേസ് പതിപ്പ് യഥാർത്ഥ പ്രതീകത്തേക്കാൾ ദൈർഘ്യമേറിയതായിരിക്കാം.

ടൈറ്റിൽകേസ് ചെയ്‌ത പതിപ്പിന്റെ ആദ്യ കോഡ് പോയിന്റ് തിരികെ ലഭിച്ചു (എന്നാൽ വിശദീകരിച്ചതുപോലെ ശ്രദ്ധിക്കുക
തൊട്ടു മുകളിൽ, കൂടുതൽ ഉണ്ടായേക്കാം.)

"p" എന്നതിലെ ഇൻപുട്ട് പ്രതീകം നന്നായി രൂപപ്പെടുത്തിയതായി അനുമാനിക്കപ്പെടുന്നു.

UV toTITLE_utf8(U8* p, U8* s, STRLEN* lenp)

toUPPER നിർദ്ദിഷ്‌ട പ്രതീകത്തെ വലിയക്ഷരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു. ഇൻപുട്ട് എന്തെങ്കിലും ആണെങ്കിൽ
ASCII ചെറിയക്ഷരം, ആ ഇൻപുട്ട് പ്രതീകം തന്നെ തിരികെ നൽകുന്നു. വേരിയന്റ്
"toUPPER_A" എന്നത് തുല്യമാണ്.

U8 മുതൽ അപ്പർ(U8 ch)

UPPER_uni വരെ
യൂണിക്കോഡ് കോഡ് പോയിന്റ് "cp" അതിന്റെ വലിയക്ഷര പതിപ്പിലേക്ക് പരിവർത്തനം ചെയ്യുകയും അതിൽ സംഭരിക്കുകയും ചെയ്യുന്നു
"s"-ൽ UTF-8, "lenp"-ൽ അതിന്റെ നീളം ബൈറ്റുകളിൽ. ബഫർ ചൂണ്ടിക്കാണിച്ചത് ശ്രദ്ധിക്കുക
"s" വഴി വലിയക്ഷരം മുതൽ കുറഞ്ഞത് "UTF8_MAXBYTES_CASE+1" ബൈറ്റുകൾ ആയിരിക്കണം
പതിപ്പ് യഥാർത്ഥ പ്രതീകത്തേക്കാൾ ദൈർഘ്യമേറിയതായിരിക്കാം.

വലിയക്ഷരത്തിലുള്ള പതിപ്പിന്റെ ആദ്യ കോഡ് പോയിന്റ് തിരികെ ലഭിച്ചു (എന്നാൽ, വിശദീകരിച്ചതുപോലെ ശ്രദ്ധിക്കുക
തൊട്ടു മുകളിൽ, കൂടുതൽ ഉണ്ടായേക്കാം.)

UV മുതൽUPPER_uni(UV cp, U8* s, STRLEN* lenp)

UPPER_utf8 വരെ
"p" എന്നതിൽ UTF-8 എൻകോഡ് ചെയ്ത പ്രതീകത്തെ അതിന്റെ വലിയക്ഷര പതിപ്പിലേക്ക് പരിവർത്തനം ചെയ്യുകയും സംഭരിക്കുകയും ചെയ്യുന്നു
UTF-8 ൽ "s" ലും അതിന്റെ ദൈർഘ്യം "lenp" ൽ ബൈറ്റിലും. ബഫർ എന്നത് ശ്രദ്ധിക്കുക
"s" ചൂണ്ടിക്കാണിക്കുന്നത് മുതൽ കുറഞ്ഞത് "UTF8_MAXBYTES_CASE+1" ബൈറ്റുകൾ ആയിരിക്കണം
വലിയക്ഷര പതിപ്പ് യഥാർത്ഥ പ്രതീകത്തേക്കാൾ ദൈർഘ്യമേറിയതായിരിക്കാം.

വലിയക്ഷരത്തിലുള്ള പതിപ്പിന്റെ ആദ്യ കോഡ് പോയിന്റ് തിരികെ ലഭിച്ചു (എന്നാൽ, വിശദീകരിച്ചതുപോലെ ശ്രദ്ധിക്കുക
തൊട്ടു മുകളിൽ, കൂടുതൽ ഉണ്ടായേക്കാം.)

"p" എന്നതിലെ ഇൻപുട്ട് പ്രതീകം നന്നായി രൂപപ്പെടുത്തിയതായി അനുമാനിക്കപ്പെടുന്നു.

UV മുതൽUPPER_utf8(U8* p, U8* s, STRLEN* lenp)

കഥാപാത്രം വർഗ്ഗീകരണം

ഈ വിഭാഗം പ്രതീകങ്ങളെ തരങ്ങളായി തരംതിരിക്കുന്ന പ്രവർത്തനങ്ങളെ (യഥാർത്ഥത്തിൽ മാക്രോകൾ) കുറിച്ചാണ്
വിരാമചിഹ്നങ്ങളും അക്ഷരമാലാക്രമവും മുതലായവ. ഇവയിൽ മിക്കതും പതിവ് പദപ്രയോഗത്തിന് സമാനമാണ്
സ്വഭാവ ക്ലാസുകൾ. (perlrecharclass ലെ "POSIX ക്യാരക്ടർ ക്ലാസുകൾ" കാണുക.) നിരവധി ഉണ്ട്
ഓരോ ക്ലാസിനും വകഭേദങ്ങൾ. (എല്ലാ മാക്രോകൾക്കും എല്ലാ വകഭേദങ്ങളും ഇല്ല; ചുവടെയുള്ള ഓരോ ഇനവും ലിസ്റ്റ് ചെയ്യുന്നു
അതിന് സാധുതയുള്ളവ.) "ഉപയോഗ ബൈറ്റുകൾ" ഒന്നും ബാധിക്കില്ല, കൂടാതെ "LC" ഉള്ളവ മാത്രം
നിലവിലെ പ്രദേശം പേരിനെ ബാധിക്കുന്നു.

അടിസ്ഥാന ഫംഗ്‌ഷൻ, ഉദാ, "isALPHA()", ഇൻപുട്ടായി ഒരു ഒക്‌റ്റെറ്റ് ("ചാർ" അല്ലെങ്കിൽ "U8") എടുക്കുന്നു
ആ ഒക്‌റ്ററ്റ് പ്രതിനിധീകരിക്കുന്ന പ്രതീകമാണോ അല്ലയോ എന്നതിനെക്കുറിച്ചുള്ള ഒരു ബൂലിയൻ നൽകുന്നു (അല്ലെങ്കിൽ
ASCII അല്ലാത്ത പ്ലാറ്റ്‌ഫോമുകളിൽ, പേരുള്ള ക്ലാസിലെ ഒരു ASCII പ്രതീകം അടിസ്ഥാനമാക്കിയുള്ളതാണ്
പ്ലാറ്റ്ഫോം, യൂണികോഡ്, പേൾ നിയമങ്ങൾ. ഇൻപുട്ട് ഒരു ഒക്ടറ്റിൽ ചേരാത്ത ഒരു സംഖ്യയാണെങ്കിൽ,
FALSE തിരികെ നൽകി.

വേരിയന്റ് "isFOO_A" (ഉദാ, "isALPHA_A()") സഫിക്‌സ് ഇല്ലാത്ത അടിസ്ഥാന ഫംഗ്‌ഷനുമായി സമാനമാണ്
"_A".

"isFOO_L1" എന്ന വകഭേദം ലാറ്റിൻ-1 (അല്ലെങ്കിൽ EBCDIC തത്തുല്യമായ) പ്രതീകം സജ്ജീകരിക്കുന്നു
പ്ലാറ്റ്ഫോം. അതായത്, ASCII ഒരു ഉപവിഭാഗമായതിനാൽ ASCII ആയ കോഡ് പോയിന്റുകളെ ബാധിക്കില്ല
ലാറ്റിൻ-1. എന്നാൽ ASCII അല്ലാത്ത കോഡ് പോയിന്റുകൾ ലാറ്റിൻ-1 പ്രതീകങ്ങൾ പോലെയാണ് പരിഗണിക്കുന്നത്.
ഉദാഹരണത്തിന്, "isWORDCHAR_L1()" എന്ന കോഡ് പോയിന്റ് 0xDF ഉപയോഗിച്ച് വിളിക്കുമ്പോൾ ശരിയാകും,
ഇത് ASCII, EBCDIC എന്നിവയിലെ ഒരു പദ പ്രതീകമാണ് (ഇത് വ്യത്യസ്തമാണ്
ഓരോന്നിലും പ്രതീകങ്ങൾ).

"isFOO_uni" എന്ന വേരിയന്റ് "isFOO_L1" വേരിയന്റ് പോലെയാണ്, എന്നാൽ ഏത് UV കോഡ് പോയിന്റും സ്വീകരിക്കുന്നു
ഇൻപുട്ട്. കോഡ് പോയിന്റ് 255-നേക്കാൾ വലുതാണെങ്കിൽ, അത് ആണോ എന്ന് നിർണ്ണയിക്കാൻ യൂണികോഡ് നിയമങ്ങൾ ഉപയോഗിക്കുന്നു
സ്വഭാവ ക്ലാസ്സിൽ. ഉദാഹരണത്തിന്, "ആണ്WORDCHAR_uni(0x100)" TRUE നൽകുന്നു, കാരണം 0x100 ആണ്
യൂണികോഡിൽ മാക്രോണിനൊപ്പം ലാറ്റിൻ ക്യാപിറ്റൽ ലെറ്റർ, ഒരു പദ പ്രതീകമാണ്.

"isFOO_utf8" എന്ന വേരിയന്റ് "isFOO_uni" പോലെയാണ്, എന്നാൽ ഇൻപുട്ട് a യിലേക്കുള്ള ഒരു പോയിന്ററാണ്.
നന്നായി രൂപപ്പെടുത്തിയത്) UTF-8 എൻകോഡ് ചെയ്ത സ്ട്രിംഗ് ("U8*" അല്ലെങ്കിൽ "char*"). എന്നതിന്റെ വർഗ്ഗീകരണം
സ്ട്രിംഗിലെ ആദ്യ (മൾട്ടി-ബൈറ്റ്) പ്രതീകം പരീക്ഷിച്ചു.

"isFOO_LC" എന്ന വേരിയന്റ് "isFOO_A", "isFOO_L1" എന്നീ വേരിയന്റുകളെ പോലെയാണ്, എന്നാൽ ഫലം അടിസ്ഥാനമാക്കിയുള്ളതാണ്
നിലവിലെ ലൊക്കേലിൽ, പേരിലെ "LC" എന്താണ് സൂചിപ്പിക്കുന്നത്. പേളിന് നിർണ്ണയിക്കാൻ കഴിയുമെങ്കിൽ
നിലവിലെ ലൊക്കേൽ ഒരു UTF-8 ലൊക്കേലാണ്, അത് പ്രസിദ്ധീകരിച്ച യൂണികോഡ് നിയമങ്ങൾ ഉപയോഗിക്കുന്നു; അല്ലാത്തപക്ഷം,
പേരുള്ള വർഗ്ഗീകരണം നൽകുന്ന സി ലൈബ്രറി ഫംഗ്‌ഷൻ ഇത് ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്,
"isDIGIT_LC()" ഒരു UTF-8 ലൊക്കേലിൽ ഇല്ലാത്തപ്പോൾ "isdigit()" എന്ന് വിളിക്കുന്നതിന്റെ ഫലം നൽകുന്നു.
ഇൻപുട്ട് ഒരു ഒക്ടറ്റിലേക്ക് യോജിച്ചില്ലെങ്കിൽ FALSE എല്ലായ്പ്പോഴും തിരികെ നൽകും. എവിടെ ചില പ്ലാറ്റ്ഫോമുകളിൽ
സി ലൈബ്രറി ഫംഗ്‌ഷൻ വികലമാണെന്ന് അറിയപ്പെടുന്നു, ഇതിനെ പിന്തുടരുന്നതിനായി പേൾ അതിന്റെ ഫലം മാറ്റുന്നു
POSIX സ്റ്റാൻഡേർഡിന്റെ നിയമങ്ങൾ.

വേരിയന്റ് "isFOO_LC_uvchr" എന്നത് "isFOO_LC" പോലെയാണ്, എന്നാൽ ഏത് UV-യിലും നിർവചിച്ചിരിക്കുന്നു. അത് തിരികെ നൽകുന്നു
256-ൽ താഴെയുള്ള ഇൻപുട്ട് കോഡ് പോയിന്റുകൾക്ക് "isFOO_LC" പോലെ തന്നെ, ഹാർഡ്-കോഡ് ചെയ്തവ നൽകുന്നു, അല്ല-
പ്രദേശം അനുസരിച്ച്, വലിയവയ്ക്ക് യൂണികോഡ് ഫലങ്ങൾ.

വേരിയന്റ് "isFOO_LC_utf8" എന്നത് "isFOO_LC_uvchr" പോലെയാണ്, എന്നാൽ ഇൻപുട്ട് ഒരു (അറിയപ്പെടുന്ന) ഒരു പോയിന്ററാണ്
നന്നായി രൂപപ്പെടുത്താൻ) UTF-8 എൻകോഡ് ചെയ്ത സ്ട്രിംഗ് ("U8*" അല്ലെങ്കിൽ "char*"). വെറും എന്ന വർഗ്ഗീകരണം
സ്ട്രിംഗിലെ ആദ്യത്തെ (മൾട്ടി-ബൈറ്റ്) പ്രതീകം പരീക്ഷിച്ചു.

isALPHA നിർദ്ദിഷ്ട പ്രതീകം അക്ഷരമാലയാണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു
പ്രതീകം, "m/[[:alpha:]]/" എന്നതിന് സമാനമാണ്. എന്നതിന് ഈ വിഭാഗത്തിന്റെ മുകളിൽ കാണുക
വേരിയന്റുകളുടെ വിശദീകരണം "isALPHA_A", "isALPHA_L1", "isALPHA_uni", "isALPHA_utf8",
"isALPHA_LC", "isALPHA_LC_uvchr", "isALPHA_LC_utf8".

bool isALPHA(char ch)

ആൽഫാന്യൂമെറിക്
നിർദ്ദിഷ്ട പ്രതീകം ഒന്നാണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു
അക്ഷരമാല അല്ലെങ്കിൽ ദശാംശ അക്കം, "m/[[:alnum:]]/" എന്നതിന് സമാനമാണ്. മുകളിൽ കാണുക
"isALPHANUMERIC_A" എന്ന വകഭേദങ്ങളുടെ വിശദീകരണത്തിനായി ഈ വിഭാഗത്തിന്റെ,
"isALPHANUMERIC_L1", "isALPHANUMERIC_uni", "isALPHANUMERIC_utf8",
"isALPHANUMERIC_LC", "isALPHANUMERIC_LC_uvchr", "isALPHANUMERIC_LC_utf8".

bool isALPHANUMERIC(char ch)

isASCII നിർദ്ദിഷ്ട പ്രതീകം 128-ൽ ഒന്നാണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു
ASCII പ്രതീക ഗണത്തിലെ പ്രതീകങ്ങൾ, "m/[[:ascii:]]/" എന്നതിന് സമാനമാണ്. അല്ലാത്തവയിൽ
ASCII പ്ലാറ്റ്‌ഫോമുകൾ, ഈ പ്രതീകം ഒരു ASCII-യുമായി പൊരുത്തപ്പെടുന്നെങ്കിൽ അത് ശരിയാണെന്ന് നൽകുന്നു
സ്വഭാവം. "isASCII_A()", "isASCII_L1()" എന്നീ വകഭേദങ്ങൾ സമാനമാണ്
"isASCII()". വേരിയന്റുകളുടെ വിശദീകരണത്തിനായി ഈ വിഭാഗത്തിന്റെ മുകളിൽ കാണുക
"isASCII_uni", "isASCII_utf8", "isASCII_LC", "isASCII_LC_uvchr", കൂടാതെ
"isASCII_LC_utf8". എന്നിരുന്നാലും, ചില പ്ലാറ്റ്‌ഫോമുകളിൽ സി ലൈബ്രറി ഇല്ല എന്നത് ശ്രദ്ധിക്കുക
പതിവ് "isascii()". ഈ സന്ദർഭങ്ങളിൽ, പേരുകളിൽ "LC" അടങ്ങിയിരിക്കുന്ന വകഭേദങ്ങളാണ്
ഇല്ലാത്ത അനുബന്ധമായവയ്ക്ക് സമാനമാണ്.

എല്ലാ ASCII പ്രതീകങ്ങളും UTF-8 മാറ്റമില്ലാത്തതിനാൽ (അവ അർത്ഥമാക്കുന്നത്
UTF-8-ൽ എൻകോഡ് ചെയ്‌താലും കൃത്യമായ അതേ പ്രാതിനിധ്യം (എല്ലായ്‌പ്പോഴും ഒരു ബൈറ്റ്) ഉണ്ടായിരിക്കും
അല്ലെങ്കിൽ അല്ല), "isASCII" ഏതെങ്കിലും ബൈറ്റ് ഉപയോഗിച്ച് വിളിക്കുമ്പോൾ ശരിയായ ഫലങ്ങൾ നൽകും
UTF-8-ൽ എൻകോഡ് ചെയ്‌തതോ അല്ലാത്തതോ ആയ സ്ട്രിംഗ്. അതുപോലെ "isASCII_utf8" ശരിയായി പ്രവർത്തിക്കും
UTF-8-ൽ എൻകോഡ് ചെയ്‌തതോ അല്ലാത്തതോ ആയ ഏതെങ്കിലും സ്‌ട്രിംഗിൽ.

bool isASCII(char ch)

isBLANK നിർദ്ദിഷ്ട പ്രതീകം ഒരു പ്രതീകമാണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു
"m/[[:blank:]]/" എന്നതിന് സമാനമായ ഒരു ശൂന്യമായി കണക്കാക്കപ്പെടുന്നു. ഇതിന്റെ മുകൾഭാഗം കാണുക
"isBLANK_A", "isBLANK_L1", "isBLANK_uni" എന്നീ വകഭേദങ്ങളുടെ വിശദീകരണത്തിനുള്ള വിഭാഗം,
"isBLANK_utf8", "isBLANK_LC", "isBLANK_LC_uvchr", "isBLANK_LC_utf8". കുറിപ്പ്,
എന്നിരുന്നാലും, ചില പ്ലാറ്റ്‌ഫോമുകളിൽ C ലൈബ്രറി പതിവ് "isblank()" ഇല്ല. ഇൻ
ഈ സന്ദർഭങ്ങളിൽ, "LC" ഉള്ള പേരുകൾ ഉള്ള വകഭേദങ്ങൾ സമാനമാണ്
ഇല്ലാത്ത അനുബന്ധമായവ.

bool isBLANK(char ch)

isCNTRL നിർദ്ദിഷ്ട പ്രതീകം ഒരു നിയന്ത്രണമാണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു
പ്രതീകം, "m/[[:cntrl:]]/" എന്നതിന് സമാനമാണ്. എന്നതിന് ഈ വിഭാഗത്തിന്റെ മുകളിൽ കാണുക
വേരിയന്റുകളുടെ വിശദീകരണം "isCNTRL_A", "isCNTRL_L1", "isCNTRL_uni", "isCNTRL_utf8",
"isCNTRL_LC", "isCNTRL_LC_uvchr", "isCNTRL_LC_utf8" എന്നിവ EBCDIC പ്ലാറ്റ്‌ഫോമുകളിൽ, നിങ്ങൾ
മിക്കവാറും എല്ലായ്‌പ്പോഴും "isCNTRL_L1" വേരിയന്റ് ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നു.

bool isCNTRL(char ch)

isDIGIT നിർദ്ദിഷ്ട പ്രതീകം ഒരു അക്കമാണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു, അത് സമാനമാണ്
"m/[[:digit:]]/" എന്നതിലേക്ക്. "isDIGIT_A", "isDIGIT_L1" എന്നീ വകഭേദങ്ങൾ സമാനമാണ്
"isDIGIT". വേരിയന്റുകളുടെ വിശദീകരണത്തിനായി ഈ വിഭാഗത്തിന്റെ മുകളിൽ കാണുക
"isDIGIT_uni", "isDIGIT_utf8", "isDIGIT_LC", "isDIGIT_LC_uvchr", കൂടാതെ
"isDIGIT_LC_utf8".

bool isDIGIT(char ch)

isGRAPH നിർദ്ദിഷ്ട പ്രതീകം ഒരു ഗ്രാഫിക് ആണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു
പ്രതീകം, "m/[[:graph:]]/" എന്നതിന് സമാനമാണ്. എന്നതിന് ഈ വിഭാഗത്തിന്റെ മുകളിൽ കാണുക
വേരിയന്റുകളുടെ വിശദീകരണം "isGRAPH_A", "isGRAPH_L1", "isGRAPH_uni", "isGRAPH_utf8",
"isGRAPH_LC", "isGRAPH_LC_uvchr", "isGRAPH_LC_utf8".

bool isGRAPH(char ch)

isIDCONT
നിർദ്ദിഷ്‌ട പ്രതീകം രണ്ടാമത്തേതാണോ അതോ ആകാം എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു
ഒരു ഐഡന്റിഫയറിന്റെ പിൻഗാമി പ്രതീകം. ഇത് വളരെ അടുത്താണ്, പക്ഷേ തികച്ചും അല്ല
ഔദ്യോഗിക യൂണികോഡ് പ്രോപ്പർട്ടി "XID_Continue" പോലെ തന്നെ. വ്യത്യാസം ഇതാണ്
ഇൻപുട്ട് പ്രതീകവും "isWORDCHAR" എന്നതുമായി പൊരുത്തപ്പെടുന്നെങ്കിൽ മാത്രമേ true നൽകുന്നുള്ളൂ. മുകളിൽ കാണുക
"isIDCONT_A", "isIDCONT_L1" എന്നീ വകഭേദങ്ങളുടെ വിശദീകരണത്തിനായി ഈ വിഭാഗത്തിന്റെ
"isIDCONT_uni", "isIDCONT_utf8", "isIDCONT_LC", "isIDCONT_LC_uvchr", കൂടാതെ
"isIDCONT_LC_utf8".

bool isIDCONT(char ch)

IDFIRST ആണ്
നിർദ്ദിഷ്‌ട പ്രതീകം ആദ്യത്തേതായിരിക്കുമോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു
ഒരു ഐഡന്റിഫയറിന്റെ സ്വഭാവം. ഇത് വളരെ അടുത്താണ്, എന്നാൽ ഇതിന് സമാനമല്ല
ഔദ്യോഗിക യൂണികോഡ് പ്രോപ്പർട്ടി "XID_Start". വ്യത്യാസം ഇത് സത്യമായി തിരിച്ചുവരുന്നു എന്നതാണ്
ഇൻപുട്ട് പ്രതീകവും "isWORDCHAR" എന്നതുമായി പൊരുത്തപ്പെടുന്നുവെങ്കിൽ മാത്രം. ഇതിന്റെ മുകൾഭാഗം കാണുക
"isIDFIRST_A", "isIDFIRST_L1" എന്ന വകഭേദങ്ങളുടെ വിശദീകരണത്തിനുള്ള വിഭാഗം,
"isIDFIRST_uni", "isIDFIRST_utf8", "isIDFIRST_LC", "isIDFIRST_LC_uvchr", കൂടാതെ
"isIDFIRST_LC_utf8".

bool isIDFIRST(char ch)

isLOWER നിർദ്ദിഷ്ട പ്രതീകം ഒരു ചെറിയക്ഷരമാണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു
പ്രതീകം, "m/[[:lower:]]/" എന്നതിന് സമാനമാണ്. എന്നതിന് ഈ വിഭാഗത്തിന്റെ മുകളിൽ കാണുക
വേരിയന്റുകളുടെ വിശദീകരണം "isLOWER_A", "isLOWER_L1", "isLOWER_uni", "isLOWER_utf8",
"isLOWER_LC", "isLOWER_LC_uvchr", "isLOWER_LC_utf8".

bool isLOWER(char ch)

isOCTAL നിർദ്ദിഷ്ട പ്രതീകം ഒക്ടൽ അക്കമാണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു,
[0-7]. "isOCTAL_A", "isOCTAL_L1" എന്നിവ മാത്രമാണ് രണ്ട് വകഭേദങ്ങൾ; ഓരോന്നും സമാനമാണ്
"isOCTAL" എന്നതിലേക്ക്.

bool isOCTAL(char ch)

isPRINT നിർദ്ദിഷ്ട പ്രതീകം അച്ചടിക്കാവുന്നതാണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു
പ്രതീകം, "m/[[:print:]]/" എന്നതിന് സമാനമാണ്. എന്നതിന് ഈ വിഭാഗത്തിന്റെ മുകളിൽ കാണുക
വേരിയന്റുകളുടെ വിശദീകരണം "isPRINT_A", "isPRINT_L1", "isPRINT_uni", "isPRINT_utf8",
"isPRINT_LC", "isPRINT_LC_uvchr", "isPRINT_LC_utf8".

bool isPRINT(char ch)

PSXSPC ആണ്
(Posix Space എന്നതിന്റെ ചുരുക്കം) 5.18 മുതൽ, ഇത് അതിന്റെ എല്ലാ രൂപങ്ങളിലും സമാനമാണ്
അനുബന്ധ "isSPACE()" മാക്രോകൾ. ഈ മാക്രോയുടെ പ്രാദേശിക രൂപങ്ങൾ ഇവയാണ്
എല്ലാ പേൾ റിലീസുകളിലും അവയുടെ അനുബന്ധ "isSPACE()" ഫോമുകൾക്ക് സമാനമാണ്. ഇൻ
5.18-ന് മുമ്പുള്ള റിലീസ്, നോൺ-ലോക്കേൽ ഫോമുകൾ അവയുടെ "isSPACE()" ഫോമുകളിൽ നിന്ന് വ്യത്യസ്തമാണ്
"isSPACE()" ഫോമുകൾ ഒരു ലംബ ടാബുമായി പൊരുത്തപ്പെടുന്നില്ല എന്നതിൽ മാത്രം
"isPSXSPC()" ഫോമുകൾ ചെയ്യുന്നു. അല്ലെങ്കിൽ, അവ സമാനമാണ്. അങ്ങനെയാണ് ഈ മാക്രോ
ഒരു സാധാരണ പദപ്രയോഗത്തിൽ "m/[[:space:]]/" പൊരുത്തപ്പെടുന്നതിനോട് സാമ്യമുണ്ട്. മുകളിൽ കാണുക
"isPSXSPC_A", "isPSXSPC_L1" എന്നീ വകഭേദങ്ങളുടെ വിശദീകരണത്തിനായി ഈ വിഭാഗത്തിന്റെ
"isPSXSPC_uni", "isPSXSPC_utf8", "isPSXSPC_LC", "isPSXSPC_LC_uvchr", കൂടാതെ
"isPSXSPC_LC_utf8".

bool isPSXSPC(char ch)

isPUNCT നിർദ്ദിഷ്ട പ്രതീകം ഒരു വിരാമചിഹ്നമാണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു
പ്രതീകം, "m/[[:punct:]]/" എന്നതിന് സമാനമാണ്. എന്താണെന്നതിന്റെ നിർവചനം ശ്രദ്ധിക്കുക
വിരാമചിഹ്നം ഒരാൾ ആഗ്രഹിക്കുന്നത്ര ലളിതമല്ല. "POSIX പ്രതീകം കാണുക
വിശദവിവരങ്ങൾക്ക് perlrecharclass-ൽ ക്ലാസുകൾ". ഒരു എന്നതിന് ഈ വിഭാഗത്തിന്റെ മുകളിൽ കാണുക
വേരിയന്റുകളുടെ വിശദീകരണം "isPUNCT_A", "isPUNCT_L1", "isPUNCT_uni", "isPUNCT_utf8",
"isPUNCT_LC", "isPUNCT_LC_uvchr", "isPUNCT_LC_utf8".

bool isPUNCT(char ch)

isSPACE നിർദ്ദിഷ്ട പ്രതീകം ഒരു വൈറ്റ്‌സ്‌പെയ്‌സ് ആണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു
സ്വഭാവം. ഒരു റെഗുലർ എക്‌സ്‌പ്രഷനിൽ "m/\s/" പൊരുത്തപ്പെടുന്നതിന് ഇത് സമാനമാണ്.
Perl 5.18-ൽ ആരംഭിക്കുന്നത് "m/[[:space:]]/" ചെയ്യുന്നതുമായി ഇതും പൊരുത്തപ്പെടുന്നു. ഇതിന് മുമ്പായി
5.18, ഈ മാക്രോയുടെ പ്രാദേശിക രൂപങ്ങൾ മാത്രം (അവരുടെ പേരിൽ "LC" ഉള്ളവ)
"m/[[:space:]]/" ചെയ്യുന്ന കാര്യങ്ങളുമായി കൃത്യമായി പൊരുത്തപ്പെടുന്നു. ആ റിലീസുകളിൽ, മാത്രം
വ്യത്യാസം, നോൺ-ലോക്കേൽ വേരിയന്റുകളിൽ, "isSPACE()" പൊരുത്തപ്പെടുന്നില്ല എന്നതായിരുന്നു a
ലംബ ടാബ്. (എല്ലാം ലംബമായ ടാബുമായി പൊരുത്തപ്പെടുന്ന ഒരു മാക്രോയ്ക്കായി "isPSXSPC" കാണുക
റിലീസുകൾ.) വേരിയന്റുകളുടെ വിശദീകരണത്തിനായി ഈ വിഭാഗത്തിന്റെ മുകളിൽ കാണുക
"isSPACE_A", "isSPACE_L1", "isSPACE_uni", "isSPACE_utf8", "isSPACE_LC",
"isSPACE_LC_uvchr", "isSPACE_LC_utf8".

bool isSPACE(char ch)

isUPPER നിർദ്ദിഷ്ട പ്രതീകം വലിയക്ഷരമാണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു
പ്രതീകം, "m/[[:upper:]]/" എന്നതിന് സമാനമാണ്. എന്നതിന് ഈ വിഭാഗത്തിന്റെ മുകളിൽ കാണുക
വേരിയന്റുകളുടെ വിശദീകരണം "isUPPER_A", "isUPPER_L1", "isUPPER_uni", "isUPPER_utf8",
"isUPPER_LC", "isUPPER_LC_uvchr", "isUPPER_LC_utf8".

bool isUPPER(char ch)

വോർഡ്ചാർ ആണ്
നിർദ്ദിഷ്ട പ്രതീകം ഒരു പ്രതീകമാണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു
ഒരു വാക്ക് പ്രതീകമാണ്, "m/\w/", "m/[[:word:]]/" എന്നിവയുമായി സാമ്യമുള്ളതാണ്.
പതിവ് ആവിഷ്കാരം. ഒരു പദ പ്രതീകം ഒരു അക്ഷരമാല പ്രതീകമാണ്, ഒരു ദശാംശ അക്കം,
ഒരു ബന്ധിപ്പിക്കുന്ന വിരാമചിഹ്ന പ്രതീകം (അണ്ടർ സ്‌കോർ പോലുള്ളവ), അല്ലെങ്കിൽ ഒരു "മാർക്ക്" പ്രതീകം
അവയിലൊന്നിൽ (ഏതോ ഉച്ചാരണരീതി പോലെ) അറ്റാച്ചുചെയ്യുന്നു. "isALNUM()" എന്നത് a
ഒരു പദ പ്രതീകം ഉൾപ്പെട്ടിട്ടുണ്ടെങ്കിലും, പിന്നോക്ക അനുയോജ്യതയ്ക്ക് പര്യായപദം നൽകിയിരിക്കുന്നു
ആൽഫാന്യൂമെറിക്കിന്റെ സാധാരണ സി ഭാഷാ അർത്ഥത്തേക്കാൾ കൂടുതൽ. ഇതിന്റെ മുകൾഭാഗം കാണുക
"isWORDCHAR_A", "isWORDCHAR_L1" എന്നീ വകഭേദങ്ങളുടെ വിശദീകരണത്തിനുള്ള വിഭാഗം,
"isWORDCHAR_uni", "isWORDCHAR_utf8". "isWORDCHAR_LC", "isWORDCHAR_LC_uvchr",
കൂടാതെ "isWORDCHAR_LC_utf8" എന്നിവയും അവിടെ വിവരിച്ചിരിക്കുന്നത് പോലെയാണ്, എന്നാൽ അധികമായി ഇവയും ഉൾപ്പെടുന്നു
പ്ലാറ്റ്‌ഫോമിന്റെ നേറ്റീവ് അടിവര.

bool isWORDCHAR(char ch)

ആണ്XDIGIT
നിർദ്ദിഷ്ട പ്രതീകം ഒരു ഹെക്സാഡെസിമൽ ആണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു
അക്കം. ASCII ശ്രേണിയിൽ ഇവ "[0-9A-Fa-f]" ആണ്. വകഭേദങ്ങൾ "isXDIGIT_A()" കൂടാതെ
"isXDIGIT_L1()" എന്നത് "isXDIGIT()" എന്നതിന് സമാനമാണ്. എന്നതിന് ഈ വിഭാഗത്തിന്റെ മുകളിൽ കാണുക
വേരിയന്റുകളുടെ വിശദീകരണം "isXDIGIT_uni", "isXDIGIT_utf8", "isXDIGIT_LC",
"isXDIGIT_LC_uvchr", "isXDIGIT_LC_utf8".

bool isXDIGIT(char ch)

ക്ലോണിംഗ് an വ്യാഖ്യാതാവ്

perl_clone
നിലവിലുള്ളത് ക്ലോൺ ചെയ്തുകൊണ്ട് ഒരു പുതിയ വ്യാഖ്യാതാവിനെ സൃഷ്‌ടിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുക.

perl_clone ഈ ഫ്ലാഗുകളെ പരാമീറ്ററുകളായി എടുക്കുന്നു:

CLONEf_COPY_STACKS - സ്റ്റാക്കുകൾ പകർത്താനും ഉപയോഗിക്കുന്നു, അതില്ലാതെ ഞങ്ങൾ മാത്രം
ഡാറ്റ ക്ലോൺ ചെയ്യുകയും സ്റ്റാക്കുകൾ പൂജ്യമാക്കുകയും ചെയ്യുക, അത് ഉപയോഗിച്ച് ഞങ്ങൾ സ്റ്റാക്കുകളും പുതിയ പേളും പകർത്തുന്നു
വ്യാഖ്യാതാവ് മുമ്പത്തെ അതേ പോയിന്റിൽ പ്രവർത്തിക്കാൻ തയ്യാറാണ്. ദി
pseudo-fork കോഡ് COPY_STACKS ഉപയോഗിക്കുമ്പോൾ ത്രെഡുകൾ->ക്രിയേറ്റ് ചെയ്യില്ല.

CLONEf_KEEP_PTR_TABLE - perl_clone പഴയതിന്റെ പോയിന്റർ ഉപയോഗിച്ച് ഒരു ptr_table സൂക്ഷിക്കുന്നു
വേരിയബിൾ ഒരു കീയായും പുതിയ വേരിയബിൾ ഒരു മൂല്യമായും, ഇത് പരിശോധിക്കാൻ അനുവദിക്കുന്നു
എന്തെങ്കിലും ക്ലോൺ ചെയ്‌തിരിക്കുന്നു, അത് വീണ്ടും ക്ലോൺ ചെയ്യാതെ മൂല്യം ഉപയോഗിക്കുക
റീകൗണ്ട് വർദ്ധിപ്പിക്കുക. KEEP_PTR_TABLE സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ, perl_clone അതിനെ നശിപ്പിക്കും
ptr_table "ptr_table_free(PL_ptr_table); PL_ptr_table = NULL;",
നിങ്ങളുടെ സ്വന്തം വേരിയബിളിൽ ചിലത് ഡ്യൂപ്പ് ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ അത് സൂക്ഷിക്കാനുള്ള കാരണം
ഗ്രാഫ് perl സ്കാനുകൾക്ക് പുറത്ത്, ഈ കോഡിന്റെ ഉദാഹരണം threads.xs create ആണ്.

CLONEf_CLONE_HOST - ഇതൊരു win32 കാര്യമാണ്, ഇത് unix-ൽ അവഗണിക്കപ്പെട്ടിരിക്കുന്നു, ഇത് perls-ൽ പറയുന്നു
സ്വയം ക്ലോൺ ചെയ്യാൻ win32host കോഡ് (അത് c++ ആണ്), നിങ്ങൾക്ക് വേണമെങ്കിൽ win32-ൽ ഇത് ആവശ്യമാണ്
ഒരേ സമയം രണ്ട് ത്രെഡുകൾ പ്രവർത്തിപ്പിക്കാൻ, നിങ്ങൾക്ക് കുറച്ച് കാര്യങ്ങൾ ചെയ്യണമെങ്കിൽ a
പേൾ ഇന്റർപ്രെറ്റർ വേർതിരിക്കുക, എന്നിട്ട് അത് വലിച്ചെറിഞ്ഞ് യഥാർത്ഥമായതിലേക്ക് മടങ്ങുക,
നിങ്ങൾ ഒന്നും ചെയ്യേണ്ടതില്ല.

PerlInterpreter* perl_clone(
PerlInterpreter *proto_perl,
യുവി പതാകകൾ
)

കംപൈൽ-സമയം സ്കോപ്പ് കൊളുത്തും

BhkDISABLE
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഉചിതമായത് മായ്‌ക്കുന്നതിലൂടെ, ഈ BHK ഘടനയിലെ ഒരു എൻട്രി താൽക്കാലികമായി പ്രവർത്തനരഹിതമാക്കുക
ഫ്ലാഗ്. ഏത് ഏത് എൻട്രി പ്രവർത്തനരഹിതമാക്കണമെന്ന് സൂചിപ്പിക്കുന്ന ഒരു പ്രീപ്രൊസസ്സർ ടോക്കൺ ആണ്.

അസാധുവായ BhkDISABLE(BHK *hk, ഏത്)

BhkENable
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഉചിതമായ ഫ്ലാഗ് സജ്ജീകരിച്ചുകൊണ്ട് ഈ BHK ഘടനയിൽ ഒരു എൻട്രി വീണ്ടും പ്രവർത്തനക്ഷമമാക്കുക. ഏത്
ഏത് എൻട്രി പ്രവർത്തനക്ഷമമാക്കണമെന്ന് സൂചിപ്പിക്കുന്ന ഒരു പ്രീപ്രോസസർ ടോക്കൺ ആണ്. ഇത് ഉറപ്പിക്കും (കീഴിൽ
-DDEBUGGING) എൻട്രിയിൽ സാധുവായ ഒരു പോയിന്റർ ഇല്ലെങ്കിൽ.

അസാധുവാണ് BhkENABLE(BHK *hk, ഏത്)

BhkENTRY_സെറ്റ്
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

BHK ഘടനയിൽ ഒരു എൻട്രി സജ്ജീകരിക്കുക, അത് സാധുതയുള്ളതാണെന്ന് സൂചിപ്പിക്കാൻ ഫ്ലാഗുകൾ സജ്ജമാക്കുക.
ഏത് ഏത് എൻട്രിയാണ് സജ്ജീകരിക്കേണ്ടതെന്ന് സൂചിപ്പിക്കുന്ന പ്രീപ്രോസസിംഗ് ടോക്കണാണ്. എന്ന തരം പിടിആർ
പ്രവേശനത്തെ ആശ്രയിച്ചിരിക്കുന്നു.

അസാധുവായ BhkENTRY_set(BHK *hk, ഏത്, അസാധുവായ *ptr)

ബ്ലോക്ക്ഹുക്ക്_രജിസ്റ്റർ
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

Perl ലെക്സിക്കൽ സ്കോപ്പ് മാറുമ്പോൾ വിളിക്കേണ്ട ഒരു കൂട്ടം ഹുക്കുകൾ രജിസ്റ്റർ ചെയ്യുക
കംപൈൽ സമയം. perlguts-ൽ "കംപൈൽ-ടൈം സ്കോപ്പ് ഹുക്കുകൾ" കാണുക.

ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷനെ ഒരു കൂടെ Perl_blockhook_register എന്ന് വ്യക്തമായി വിളിക്കണം
aTHX_ പരാമീറ്റർ.

അസാധുവായ Perl_blockhook_register(pTHX_ BHK *hk)

COP സൂചന ഹാഷുകൾ

cophh_2hv
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

കീ/മൂല്യത്തിന്റെ മുഴുവൻ സെറ്റും പ്രതിനിധീകരിക്കുന്ന ഒരു സ്റ്റാൻഡേർഡ് പേൾ ഹാഷ് സൃഷ്ടിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു
കോപ്പിലെ ജോഡികൾ ഹാഷ് സൂചന നൽകുന്നു cophh. ഫ്ലാഗുകൾ നിലവിൽ ഉപയോഗിക്കാത്തതും പൂജ്യമായിരിക്കണം.

HV * cophh_2hv(const COPHH *cophh, U32 ഫ്ലാഗുകൾ)

cophh_copy
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

കോപ്പ് സൂചനകൾ ഹാഷിന്റെ പൂർണ്ണമായ പകർപ്പ് ഉണ്ടാക്കി തിരികെ നൽകുക cophh.

COPHH * cophh_copy(COPHH *cophh)

cophh_delete_pv
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

"cophh_delete_pvn" പോലെ, എന്നാൽ a ന് പകരം ഒരു nul-terminated string എടുക്കുന്നു
സ്ട്രിംഗ്/നീളം ജോടി.

COPHH * cophh_delete_pv(const COPHH *cophh,
കോൺസ്റ്റ് ചാർ *കീ, U32 ഹാഷ്,
U32 പതാകകൾ)

cophh_delete_pvn
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

കോപ്പ് സൂചനകൾ ഹാഷിൽ നിന്ന് ഒരു കീയും അതുമായി ബന്ധപ്പെട്ട മൂല്യവും ഇല്ലാതാക്കുക cophh, തിരിച്ചുവരുന്നു
പരിഷ്കരിച്ച ഹാഷ്. തിരികെ നൽകിയ ഹാഷ് പോയിന്റർ പൊതുവെ സമാനമല്ല
ഹാഷ് പോയിന്റർ കടന്നു
അതിലേക്കുള്ള പോയിന്റർ പിന്നീട് ഉപയോഗിക്കാൻ പാടില്ല. നിങ്ങൾക്ക് വേണമെങ്കിൽ "cophh_copy" ഉപയോഗിക്കുക
രണ്ട് ഹാഷുകളും.

കീ വ്യക്തമാക്കുന്നു കീപിവി ഒപ്പം കീലെൻ. എങ്കിൽ ഫ്ലാഗുകൾ "COPHH_KEY_UTF8" ബിറ്റ് ഉണ്ട്
സെറ്റ്, കീ ഒക്ടറ്റുകളെ UTF-8 ആയി വ്യാഖ്യാനിക്കുന്നു, അല്ലാത്തപക്ഷം അവ വ്യാഖ്യാനിക്കുന്നു
ലാറ്റിൻ-1. ഹാഷ് കീ സ്‌ട്രിംഗിന്റെ പ്രീകമ്പ്യൂട്ടഡ് ഹാഷ് ആണ്, അല്ലെങ്കിൽ അത് ഇല്ലെങ്കിൽ പൂജ്യം
മുൻകൂട്ടി കണക്കുകൂട്ടിയ.

COPHH * cophh_delete_pvn(COPHH *cophh,
കോൺസ്റ്റ് ചാർ *കീപിവി,
STRLEN കീലെൻ, U32 ഹാഷ്,
U32 പതാകകൾ)

cophh_delete_pvs
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

"cophh_delete_pvn" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/നീളത്തിന് പകരം അക്ഷരാർത്ഥത്തിലുള്ള ഒരു സ്ട്രിംഗ് എടുക്കുന്നു
ജോടി, കൂടാതെ മുൻകൂട്ടി തയ്യാറാക്കിയ ഹാഷ് ഇല്ല.

COPHH * cophh_delete_pvs(const COPHH *cophh,
കോൺസ്റ്റ് ചാർ *കീ, U32 ഫ്ലാഗുകൾ)

cophh_delete_sv
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

"cophh_delete_pvn" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/ലെങ്ത്ത് ജോഡിക്ക് പകരം ഒരു Perl സ്കെയിലർ എടുക്കുന്നു.

COPHH * cophh_delete_sv(const COPHH *cophh, SV *കീ,
U32 ഹാഷ്, U32 ഫ്ലാഗുകൾ)

cophh_fetch_pv
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

"cophh_fetch_pvn" പോലെ, എന്നാൽ a ന് പകരം nul-terminated string എടുക്കുന്നു
സ്ട്രിംഗ്/നീളം ജോടി.

SV * cophh_fetch_pv(const COPHH *cophh,
കോൺസ്റ്റ് ചാർ *കീ, U32 ഹാഷ്,
U32 പതാകകൾ)

cophh_fetch_pvn
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

കോപ്പ് സൂചനകൾ ഹാഷിലെ എൻട്രി നോക്കുക cophh വ്യക്തമാക്കിയ കീ ഉപയോഗിച്ച് കീപിവി ഒപ്പം
കീലെൻ. എങ്കിൽ ഫ്ലാഗുകൾ "COPHH_KEY_UTF8" ബിറ്റ് സെറ്റ് ഉണ്ട്, കീ ഒക്റ്ററ്റുകൾ വ്യാഖ്യാനിക്കപ്പെടുന്നു
UTF-8 ആയി, അല്ലാത്തപക്ഷം അവ ലാറ്റിൻ-1 ആയി വ്യാഖ്യാനിക്കപ്പെടുന്നു. ഹാഷ് ഒരു മുൻകമ്പ്യൂട്ടഡ് ഹാഷ് ആണ്
കീ സ്ട്രിംഗിന്റെ, അല്ലെങ്കിൽ അത് മുൻകൂട്ടി കമ്പ്യൂട്ട് ചെയ്തിട്ടില്ലെങ്കിൽ പൂജ്യം. ഒരു മർത്യനെ തിരികെ നൽകുന്നു
കീയുമായി ബന്ധപ്പെട്ട മൂല്യത്തിന്റെ സ്കെയിലർ കോപ്പി, അല്ലെങ്കിൽ &PL_sv_placeholder ഉണ്ടെങ്കിൽ
കീയുമായി ബന്ധപ്പെട്ട മൂല്യമില്ല.

SV * cophh_fetch_pvn(const COPHH *cophh,
കോൺസ്റ്റ് ചാർ *കീപിവി,
STRLEN കീലെൻ, U32 ഹാഷ്,
U32 പതാകകൾ)

cophh_fetch_pvs
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

"cophh_fetch_pvn" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/നീളത്തിന് പകരം അക്ഷരാർത്ഥത്തിലുള്ള ഒരു സ്ട്രിംഗ് എടുക്കുന്നു
ജോടി, കൂടാതെ മുൻകൂട്ടി തയ്യാറാക്കിയ ഹാഷ് ഇല്ല.

SV * cophh_fetch_pvs(const COPHH *cophh,
കോൺസ്റ്റ് ചാർ *കീ, U32 ഫ്ലാഗുകൾ)

cophh_fetch_sv
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

"cophh_fetch_pvn" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/ലെങ്ത്ത് ജോഡിക്ക് പകരം ഒരു Perl സ്കെയിലർ എടുക്കുന്നു.

SV * cophh_fetch_sv(const COPHH *cophh, SV *കീ,
U32 ഹാഷ്, U32 ഫ്ലാഗുകൾ)

cophh_free
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

കോപ്പ് സൂചനകൾ ഹാഷ് ഉപേക്ഷിക്കുക cophh, അതുമായി ബന്ധപ്പെട്ട എല്ലാ വിഭവങ്ങളും സ്വതന്ത്രമാക്കുന്നു.

ശൂന്യമായ cophh_free(COPHH *cophh)

cophh_new_empty
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

എൻട്രികളൊന്നും അടങ്ങിയിട്ടില്ലാത്ത ഒരു പുതിയ കോപ്പ് സൂചനകൾ ഹാഷ് സൃഷ്ടിച്ച് തിരികെ നൽകുക.

COPHH * cophh_new_empty()

cophh_store_pv
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

"cophh_store_pvn" പോലെ, എന്നാൽ a ന് പകരം nul-terminated string എടുക്കുന്നു
സ്ട്രിംഗ്/നീളം ജോടി.

COPHH * cophh_store_pv(const COPHH *cophh,
കോൺസ്റ്റ് ചാർ *കീ, U32 ഹാഷ്,
SV *മൂല്യം, U32 പതാകകൾ)

cophh_store_pvn
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു കീയുമായി ബന്ധപ്പെട്ട ഒരു മൂല്യം, കോപ്പ് സൂചനകൾ ഹാഷിൽ സംഭരിക്കുന്നു cophh, തിരിച്ചുവരുന്നു
പരിഷ്കരിച്ച ഹാഷ്. തിരികെ നൽകിയ ഹാഷ് പോയിന്റർ പൊതുവെ സമാനമല്ല
ഹാഷ് പോയിന്റർ കടന്നു
അതിലേക്കുള്ള പോയിന്റർ പിന്നീട് ഉപയോഗിക്കാൻ പാടില്ല. നിങ്ങൾക്ക് വേണമെങ്കിൽ "cophh_copy" ഉപയോഗിക്കുക
രണ്ട് ഹാഷുകളും.

കീ വ്യക്തമാക്കുന്നു കീപിവി ഒപ്പം കീലെൻ. എങ്കിൽ ഫ്ലാഗുകൾ "COPHH_KEY_UTF8" ബിറ്റ് ഉണ്ട്
സെറ്റ്, കീ ഒക്ടറ്റുകളെ UTF-8 ആയി വ്യാഖ്യാനിക്കുന്നു, അല്ലാത്തപക്ഷം അവ വ്യാഖ്യാനിക്കുന്നു
ലാറ്റിൻ-1. ഹാഷ് കീ സ്‌ട്രിംഗിന്റെ പ്രീകമ്പ്യൂട്ടഡ് ഹാഷ് ആണ്, അല്ലെങ്കിൽ അത് ഇല്ലെങ്കിൽ പൂജ്യം
മുൻകൂട്ടി കണക്കുകൂട്ടിയ.

മൂല്യം ഈ കീയ്ക്കായി സംഭരിക്കേണ്ട സ്കെയിലർ മൂല്യമാണ്. മൂല്യം ഇതിലൂടെ പകർത്തിയിരിക്കുന്നു
ഫംഗ്‌ഷൻ, അങ്ങനെ അതിനെക്കുറിച്ചുള്ള ഒരു റഫറൻസിന്റെയും ഉടമസ്ഥാവകാശം എടുക്കുന്നില്ല, പിന്നീട്
സ്കെയിലറിലെ മാറ്റങ്ങൾ കോപ്പ് സൂചനകളിൽ ദൃശ്യമാകുന്ന മൂല്യത്തിൽ പ്രതിഫലിക്കില്ല
ഹാഷ്. സങ്കീർണ്ണമായ തരത്തിലുള്ള സ്കെയിലർ റഫറൻഷ്യൽ സമഗ്രതയോടെ സൂക്ഷിക്കില്ല, പക്ഷേ
ചരടുകളിലേക്ക് നിർബന്ധിക്കും.

COPHH * cophh_store_pvn(COPHH *cophh, const char *keypv,
STRLEN കീലെൻ, U32 ഹാഷ്,
SV *മൂല്യം, U32 പതാകകൾ)

cophh_store_pvs
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

"cophh_store_pvn" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/നീളത്തിന് പകരം ഒരു അക്ഷര സ്ട്രിംഗ് എടുക്കുന്നു
ജോടി, കൂടാതെ മുൻകൂട്ടി തയ്യാറാക്കിയ ഹാഷ് ഇല്ല.

COPHH * cophh_store_pvs(const COPHH *cophh,
കോൺസ്റ്റ് ചാർ *കീ, എസ്വി *മൂല്യം,
U32 പതാകകൾ)

cophh_store_sv
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

"cophh_store_pvn" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/ലെങ്ത്ത് ജോഡിക്ക് പകരം ഒരു Perl സ്കെയിലർ എടുക്കുന്നു.

COPHH * cophh_store_sv(const COPHH *cophh, SV *കീ,
U32 ഹാഷ്, SV *മൂല്യം, U32 ഫ്ലാഗുകൾ)

COP സൂചന വായന

cop_hints_2hv
സൂചനയുടെ മുഴുവൻ സെറ്റും പ്രതിനിധീകരിക്കുന്ന ഒരു സ്റ്റാൻഡേർഡ് പേൾ ഹാഷ് സൃഷ്ടിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു
കോപ്പിലെ എൻട്രികൾ കോപ്പ്. ഫ്ലാഗുകൾ നിലവിൽ ഉപയോഗിക്കാത്തതും പൂജ്യമായിരിക്കണം.

HV * cop_hints_2hv(const COP *cop, U32 ഫ്ലാഗുകൾ)

cop_hints_fetch_pv
"cop_hints_fetch_pvn" പോലെ, എന്നാൽ a ന് പകരം ഒരു nul-terminated string എടുക്കുന്നു
സ്ട്രിംഗ്/നീളം ജോടി.

SV * cop_hints_fetch_pv(const COP *cop,
കോൺസ്റ്റ് ചാർ *കീ, U32 ഹാഷ്,
U32 പതാകകൾ)

cop_hints_fetch_pvn
പോലീസിലെ സൂചന എൻട്രി നോക്കുക കോപ്പ് വ്യക്തമാക്കിയ കീ ഉപയോഗിച്ച് കീപിവി ഒപ്പം കീലെൻ.
If ഫ്ലാഗുകൾ "COPHH_KEY_UTF8" ബിറ്റ് സെറ്റ് ഉണ്ട്, കീ ഒക്ടറ്റുകളെ ഇങ്ങനെ വ്യാഖ്യാനിക്കുന്നു
UTF-8, അല്ലാത്തപക്ഷം അവ ലാറ്റിൻ-1 ആയി വ്യാഖ്യാനിക്കപ്പെടുന്നു. ഹാഷ് യുടെ പ്രീകമ്പ്യൂട്ടഡ് ഹാഷ് ആണ്
കീ സ്ട്രിംഗ്, അല്ലെങ്കിൽ അത് മുൻകൂട്ടി കമ്പ്യൂട്ട് ചെയ്തിട്ടില്ലെങ്കിൽ പൂജ്യം. ഒരു മാരക സ്കെയിലർ നൽകുന്നു
കീയുമായി ബന്ധപ്പെട്ട മൂല്യത്തിന്റെ പകർപ്പ്, അല്ലെങ്കിൽ ഇല്ലെങ്കിൽ &PL_sv_placeholder
കീയുമായി ബന്ധപ്പെട്ട മൂല്യം.

SV * cop_hints_fetch_pvn(const COP *cop,
കോൺസ്റ്റ് ചാർ *കീപിവി,
STRLEN കീലെൻ, U32 ഹാഷ്,
U32 പതാകകൾ)

cop_hints_fetch_pvs
"cop_hints_fetch_pvn" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/നീളത്തിന് പകരം ഒരു അക്ഷര സ്ട്രിംഗ് എടുക്കുന്നു
ജോടി, കൂടാതെ മുൻകൂട്ടി തയ്യാറാക്കിയ ഹാഷ് ഇല്ല.

SV * cop_hints_fetch_pvs(const COP *cop,
കോൺസ്റ്റ് ചാർ *കീ, U32 ഫ്ലാഗുകൾ)

cop_hints_fetch_sv
"cop_hints_fetch_pvn" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/നീളത്തിന് പകരം ഒരു പേൾ സ്കെയിലർ എടുക്കുന്നു
ജോഡി.

SV * cop_hints_fetch_sv(const COP *cop, SV *key,
U32 ഹാഷ്, U32 ഫ്ലാഗുകൾ)

കസ്റ്റം ഓപ്പറേറററുകളും

custom_op_register
ഒരു ഇഷ്‌ടാനുസൃത OP രജിസ്റ്റർ ചെയ്യുക. perlguts-ൽ "ഇഷ്‌ടാനുസൃത ഓപ്പറേറ്റർമാർ" കാണുക.

ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷനെ Perl_custom_op_register എന്ന് വ്യക്തമായി വിളിക്കണം.
aTHX_ പരാമീറ്റർ.

അസാധുവായ Perl_custom_op_register(pTHX_
Perl_ppaddr_t paddr,
const XOP *xop)

custom_op_xop
തന്നിരിക്കുന്ന ഇഷ്‌ടാനുസൃത ഓപ്പിനായി XOP ഘടന തിരികെ നൽകുക. ഈ മാക്രോ പരിഗണിക്കണം
OP_NAME എന്നതിലേക്കും മറ്റ് ആക്‌സസ് മാക്രോകളിലേക്കും ആന്തരികം: പകരം അവ ഉപയോഗിക്കുക. ഈ മാക്രോ
ഒരു ഫംഗ്‌ഷൻ വിളിക്കുന്നു. 5.19.6 ന് മുമ്പ്, ഇത് ഒരു ചടങ്ങായി നടപ്പിലാക്കി.

ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷനെ aTHX_ ഉപയോഗിച്ച് Perl_custom_op_xop എന്ന് വ്യക്തമായി വിളിക്കണം
പാരാമീറ്റർ.

const XOP * Perl_custom_op_xop(pTHX_ const OP *o)

Xopഡിസബിൾ
ഉചിതമായ ഫ്ലാഗ് മായ്‌ക്കുന്നതിലൂടെ XOP-ലെ ഒരു അംഗത്തെ താൽക്കാലികമായി പ്രവർത്തനരഹിതമാക്കുക.

ശൂന്യമായ XopDISABLE(XOP *xop, ഏത്)

XopENable
പ്രവർത്തനരഹിതമാക്കിയ XOP അംഗത്തെ വീണ്ടും പ്രവർത്തനക്ഷമമാക്കുക.

ശൂന്യമായ XopENABLE(XOP *xop, ഏത്)

XopENTRY
XOP ഘടനയിലെ ഒരു അംഗത്തെ തിരികെ നൽകുക. ഏത് ഏത് എൻട്രി എന്ന് സൂചിപ്പിക്കുന്ന ഒരു cpp ടോക്കൺ ആണ്
മടങ്ങാൻ. അംഗത്തെ സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ, ഇത് ഒരു സ്ഥിര മൂല്യം നൽകും. തിരിച്ചുവരവ്
തരം ആശ്രയിച്ചിരിക്കുന്നു ഏത്. ഈ മാക്രോ അതിന്റെ വാദങ്ങൾ ഒന്നിലധികം തവണ വിലയിരുത്തുന്നു. നിങ്ങൾ എങ്കിൽ
ഒരു "OP *" ൽ നിന്ന് ഒരു "XOP *" വീണ്ടെടുക്കാൻ "Perl_custom_op_xop" ഉപയോഗിക്കുന്നു, കൂടുതൽ ഉപയോഗിക്കുക
പകരം കാര്യക്ഷമമായ "XopENTRYCUSTOM".

XopENTRY(XOP *xop, ഏത്)

XopENTRYCUSTOM
കൃത്യമായി "XopENTRY(XopENTRY(Perl_custom_op_xop(aTHX_ o), ഏത്)"" എന്നാൽ കൂടുതൽ
കാര്യക്ഷമമായ. ദി ഏത് പാരാമീറ്റർ "XopENTRY" ന് സമാനമാണ്.

XopENTRYCUSTOM(const OP *o, ഏത്)

XopENTRY_set
XOP ഘടനയിൽ ഒരു അംഗത്തെ സജ്ജമാക്കുക. ഏത് ഏത് എൻട്രിയിലേക്കാണ് പ്രവേശിക്കുന്നതെന്ന് സൂചിപ്പിക്കുന്ന ഒരു cpp ടോക്കൺ ആണ്
സെറ്റ്. ലഭ്യമായ അംഗങ്ങളെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾക്ക് perlguts-ൽ "ഇഷ്‌ടാനുസൃത ഓപ്പറേറ്റർമാർ" കാണുക
അവ എങ്ങനെ ഉപയോഗിക്കുന്നു എന്നതും. ഈ മാക്രോ അതിന്റെ വാദം ഒന്നിലധികം തവണ വിലയിരുത്തുന്നു.

അസാധുവായ XopENTRY_set(XOP *xop, ഏത്, മൂല്യം)

XopFLAGS
XOP-യുടെ ഫ്ലാഗുകൾ തിരികെ നൽകുക.

U32 XopFLAGS(XOP *xop)

CV കൃത്രിമം പ്രവർത്തനങ്ങൾ

കോഡ് മൂല്യങ്ങൾ അല്ലെങ്കിൽ സബ്റൂട്ടീനുകൾ ആയ CV-കൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള പ്രവർത്തനങ്ങൾ ഈ വിഭാഗം ഡോക്യുമെന്റ് ചെയ്യുന്നു.
കൂടുതൽ വിവരങ്ങൾക്ക്, perlguts കാണുക.

caller_cx
XSUB-റൈറ്ററിന് തുല്യമായത് വിളിക്കുന്നയാൾ(). തിരികെ നൽകിയ "PERL_CONTEXT" ഘടന
"കോളർ" മുഖേന പേളിലേക്ക് മടങ്ങിയ എല്ലാ വിവരങ്ങളും കണ്ടെത്താൻ ചോദ്യം ചെയ്യാവുന്നതാണ്.
XSUB-കൾക്ക് ഒരു സ്റ്റാക്ക് ഫ്രെയിം ലഭിക്കുന്നില്ല എന്ന കാര്യം ശ്രദ്ധിക്കുക, അതിനാൽ "caller_cx(0, NULL)" തിരികെ വരും
ഉടൻ ചുറ്റുമുള്ള പേൾ കോഡിനുള്ള വിവരങ്ങൾ.

&DB::sub എന്നതിലേക്കുള്ള സ്വയമേവയുള്ള കോളുകൾ ഈ ഫംഗ്‌ഷൻ ഒഴിവാക്കുന്നു
ഡീബഗ്ഗർ. അഭ്യർത്ഥിച്ച സ്റ്റാക്ക് ഫ്രെയിം "DB::sub" എന്ന് വിളിക്കുന്ന ഒരു സബ് ആണെങ്കിൽ, റിട്ടേൺ
"DB::sub" എന്നതിലേക്കുള്ള കോളിന്റെ ഫ്രെയിം ആയിരിക്കും മൂല്യം, കാരണം അതിന് ശരിയായ ലൈൻ ഉണ്ട്
നമ്പർ/തുടങ്ങിയവ. കോൾ സൈറ്റിനായി. എങ്കിൽ dbcxp "NULL" അല്ല, അത് a ആയി സജ്ജീകരിക്കും
സബ് കോളിനുള്ള ഫ്രെയിമിലേക്കുള്ള പോയിന്റർ.

const PERL_CONTEXT * caller_cx(
I32 ലെവൽ,
const PERL_CONTEXT **dbcxp
)

CvSTASH CV യുടെ സ്റ്റാഷ് നൽകുന്നു. ഒരു സ്റ്റാഷ് എന്നത് ചിഹ്ന ടേബിൾ ഹാഷാണ്, അതിൽ അടങ്ങിയിരിക്കുന്നു
സബ്റൂട്ടീൻ നിർവചിച്ചിരിക്കുന്ന പാക്കേജിലെ പാക്കേജ്-സ്കോപ്പ്ഡ് വേരിയബിളുകൾ. വേണ്ടി
കൂടുതൽ വിവരങ്ങൾ, perlguts കാണുക.

XS AUTOLOAD സബ്‌സ് ഉപയോഗിച്ചും ഇതിന് ഒരു പ്രത്യേക ഉപയോഗമുണ്ട്. "XSUBs ഉപയോഗിച്ച് ഓട്ടോലോഡിംഗ്" കാണുക
perlguts ൽ.

HV* CvSTASH(CV* cv)

find_runcv
നിലവിൽ എക്സിക്യൂട്ട് ചെയ്യുന്ന സബ് അല്ലെങ്കിൽ എവലുമായി ബന്ധപ്പെട്ട CV കണ്ടെത്തുക. db_seqp ആണെങ്കിൽ
non_null, DB പാക്കേജിലുള്ള CV-കൾ ഒഴിവാക്കുക, പോലീസുമായി *db_seqp പോപ്പുലേറ്റ് ചെയ്യുക
DB:: കോഡ് നൽകിയ പോയിന്റിലെ സീക്വൻസ് നമ്പർ. (ഇത് അനുവദിക്കുന്നു
ഡീബഗ്ഗറുകൾ ബ്രേക്ക്‌പോയിന്റിന്റെ വ്യാപ്തിയിലല്ല
ഡീബഗ്ഗർ തന്നെ.)

CV* find_runcv(U32 *db_seqp)

get_cv "പേരിന്റെ" ദൈർഘ്യം ലഭിക്കാൻ "strlen" ഉപയോഗിക്കുന്നു, തുടർന്ന് "get_cvn_flags" എന്ന് വിളിക്കുന്നു.

ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷന്റെ perl_ ഫോം ഒഴിവാക്കിയിരിക്കുന്നു.

CV* get_cv(const char* name, I32 ഫ്ലാഗുകൾ)

get_cvn_flags
നിർദ്ദിഷ്‌ട Perl സബ്റൂട്ടീന്റെ CV നൽകുന്നു. "പതാകകൾ" കൈമാറുന്നു
"gv_fetchpvn_flags". "GV_ADD" സജ്ജീകരിക്കുകയും പേൾ സബ്റൂട്ടീൻ നിലവിലില്ലെങ്കിൽ
അപ്പോൾ അത് പ്രഖ്യാപിക്കപ്പെടും (ഇതിന് "ഉപ നാമം;" എന്ന് പറയുന്നതിന് സമാനമായ ഫലമുണ്ട്). എങ്കിൽ
"GV_ADD" സജ്ജീകരിച്ചിട്ടില്ല, സബ്റൂട്ടീൻ നിലവിലില്ല, തുടർന്ന് NULL തിരികെ നൽകും.

ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷന്റെ perl_ ഫോം ഒഴിവാക്കിയിരിക്കുന്നു.

CV* get_cvn_flags(const char* name, STRLEN ലെൻ,
I32 പതാകകൾ)

ഡീബഗ്ഗിംഗ് യൂട്ടിലിറ്റികൾ

എല്ലാം ഡംപ്
"PL_main_root"-ൽ ആരംഭിക്കുന്ന നിലവിലെ പ്രോഗ്രാമിന്റെ മുഴുവൻ ഒപ്ട്രീയും ഡംപ് ചെയ്യുന്നു
"STDERR". "PL_defstash"-ൽ ദൃശ്യമാകുന്ന എല്ലാ സബ്റൂട്ടീനുകൾക്കുമായി ഒപ്ട്രീസിനെ ഡംപ് ചെയ്യുന്നു.

void dump_all()

dump_packsubs
"സ്‌റ്റാഷിൽ" ദൃശ്യമാകുന്ന എല്ലാ സബ്‌റൂട്ടീനുകൾക്കുമുള്ള ഒപ്‌ട്രീസിനെ ഡംപ് ചെയ്യുന്നു.

void dump_packsubs(const HV* stash)

op_dump OP "o" ൽ ആരംഭിക്കുന്ന ഒപ്ട്രീയെ "STDERR" ലേക്ക് ഡംപ് ചെയ്യുന്നു.

ശൂന്യമായ op_dump (const OP *o)

sv_dump "STDERR" ഫയൽഹാൻഡിലിലേക്ക് ഒരു SV-യുടെ ഉള്ളടക്കം ഡംപ് ചെയ്യുന്നു.

അതിന്റെ ഔട്ട്പുട്ടിന്റെ ഒരു ഉദാഹരണത്തിനായി, Devel ::Peek കാണുക.

ശൂന്യമായ sv_dump(SV* sv)

പ്രദർശിപ്പിക്കുക ഒപ്പം ഉപേക്ഷിക്കുക ഫംഗ്ഷനുകളും

pv_display
സമാനമായ

pv_escape(dsv,pv,cur,pvlim,PERL_PV_ESCAPE_QUOTE);

len > cur and ആകുമ്പോൾ ഒരു അധിക "\0" സ്ട്രിംഗിൽ ചേർക്കും
pv[cur] "\0" ആണ്.

അവസാന സ്‌ട്രിംഗിന് pvlim-നേക്കാൾ 7 അക്ഷരങ്ങൾ വരെ നീളമുണ്ടാകുമെന്നത് ശ്രദ്ധിക്കുക.

char* pv_display(SV *dsv, const char *pv, STRLEN cur,
STRLEN ലെൻ, STRLEN pvlim)

pv_escape
pv-യുടെ ആദ്യത്തെ "എണ്ണം" അക്ഷരങ്ങളിൽ നിന്ന് പരമാവധി രക്ഷപ്പെടുകയും ഫലങ്ങൾ dsv-യിലേക്ക് നൽകുകയും ചെയ്യുന്നു.
രക്ഷപ്പെട്ട സ്ട്രിംഗിന്റെ വലുപ്പം "പരമാവധി" അക്ഷരങ്ങളിൽ കവിയാൻ പാടില്ല
ഏതെങ്കിലും അപൂർണ്ണമായ രക്ഷപ്പെടൽ സീക്വൻസുകൾ അടങ്ങിയിരിക്കുന്നു. രക്ഷപ്പെട്ട ബൈറ്റുകളുടെ എണ്ണം ആയിരിക്കും
അത് ശൂന്യമല്ലെങ്കിൽ STRLEN *escaped പാരാമീറ്ററിൽ തിരിച്ചെത്തി. എപ്പോൾ dsv
പാരാമീറ്റർ ശൂന്യമാണ് രക്ഷപ്പെടൽ യഥാർത്ഥത്തിൽ സംഭവിക്കുന്നില്ല, പക്ഷേ ബൈറ്റുകളുടെ എണ്ണം
അസാധുവായി കണക്കാക്കില്ല എങ്കിൽ രക്ഷപ്പെടും.

ഫ്ലാഗുകളിൽ PERL_PV_ESCAPE_QUOTE അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, സ്ട്രിംഗിലെ ഏതെങ്കിലും ഇരട്ട ഉദ്ധരണികൾ
കൂടാതെ രക്ഷപ്പെടും.

സാധാരണ ഗതിയിൽ എസ്‌വി മായ്‌ക്കപ്പെടും, എന്നാൽ എപ്പോൾ
ഇത് സംഭവിക്കില്ലെന്ന് PERL_PV_ESCAPE_NOCLEAR സജ്ജീകരിച്ചിരിക്കുന്നു.

PERL_PV_ESCAPE_UNI സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, ഇൻപുട്ട് സ്ട്രിംഗ് UTF-8 ആയി കണക്കാക്കുന്നു
PERL_PV_ESCAPE_UNI_DETECT സജ്ജീകരിച്ച ശേഷം ഇൻപുട്ട് സ്ട്രിംഗ് ഉപയോഗിച്ച് സ്കാൻ ചെയ്യുന്നു
UTF-8 ആണോ എന്ന് നിർണ്ണയിക്കാൻ "is_utf8_string()".

PERL_PV_ESCAPE_ALL സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, എല്ലാ ഇൻപുട്ട് ചാറുകളും "\x01F1" ഉപയോഗിച്ച് ഔട്ട്പുട്ട് ചെയ്യും
ശൈലി രക്ഷപ്പെടും, അല്ലാത്തപക്ഷം PERL_PV_ESCAPE_NONASCII സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, ASCII അല്ലാത്ത അക്ഷരങ്ങൾ മാത്രം
ഈ ശൈലി ഉപയോഗിച്ച് രക്ഷപ്പെടും; അല്ലെങ്കിൽ, 255-ന് മുകളിലുള്ള അക്ഷരങ്ങൾ മാത്രമേ അങ്ങനെയായിരിക്കൂ
രക്ഷപ്പെട്ടു; മറ്റ് അച്ചടിക്കാനാവാത്ത അക്ഷരങ്ങൾ ഒക്ടൽ അല്ലെങ്കിൽ സാധാരണ എസ്കേപ്പ്ഡ് പാറ്റേണുകൾ ഉപയോഗിക്കും
"\n". അല്ലെങ്കിൽ, PERL_PV_ESCAPE_NOBACKSLASH ആണെങ്കിൽ 255-ന് താഴെയുള്ള എല്ലാ അക്ഷരങ്ങളും ആയിരിക്കും
അച്ചടിക്കാവുന്നവയായി കണക്കാക്കുകയും അത് അക്ഷരാർത്ഥത്തിൽ ഔട്ട്പുട്ട് ചെയ്യുകയും ചെയ്യും.

PERL_PV_ESCAPE_FIRSTCHAR സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, സ്ട്രിംഗിന്റെ ആദ്യ പ്രതീകം മാത്രമായിരിക്കും
പരമാവധി പരിഗണിക്കാതെ രക്ഷപ്പെട്ടു. ഔട്ട്‌പുട്ട് ഹെക്‌സിൽ ആയിരിക്കണമെങ്കിൽ, അത് ആയിരിക്കും
ഒരു പ്ലെയിൻ ഹെക്സ് സീക്വൻസായി മടങ്ങി. അങ്ങനെ ഔട്ട്പുട്ട് ഒന്നുകിൽ ഒറ്റ ചാർ ആയിരിക്കും,
ഒരു ഒക്ടൽ എസ്കേപ്പ് സീക്വൻസ്, "\n" അല്ലെങ്കിൽ ഒരു ഹെക്സ് മൂല്യം പോലെയുള്ള ഒരു പ്രത്യേക എസ്കേപ്പ്.

PERL_PV_ESCAPE_RE സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, എസ്കേപ്പ് ചാർ '%' ആയിരിക്കും, ഒരു അല്ല
'\\'. കാരണം, റീജക്‌സുകളിൽ പലപ്പോഴും ബാക്ക്‌സ്ലാഷ് സീക്വൻസുകൾ അടങ്ങിയിട്ടുണ്ട്
പാറ്റേണുകളിൽ '%' എന്നത് ഒരു സാധാരണ പ്രതീകമല്ല.

dsv കൈവശം വച്ചിരിക്കുന്ന പോലെ രക്ഷപ്പെട്ട വാചകത്തിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു.

char* pv_escape(SV *dsv, char const * const str,
const STRLEN എണ്ണം, const STRLEN പരമാവധി,
STRLEN * const രക്ഷപ്പെട്ടു,
const U32 പതാകകൾ)

pv_pretty
ഒരു സ്‌ട്രിംഗിനെ അവതരിപ്പിക്കാനാകുന്ന ഒന്നാക്കി മാറ്റുന്നു, എസ്കേപ്പിംഗ് വഴി കൈകാര്യം ചെയ്യുന്നു pv_escape()
ഒപ്പം ഉദ്ധരണികളെയും ദീർഘവൃത്തങ്ങളെയും പിന്തുണയ്ക്കുന്നു.

PERL_PV_PRETTY_QUOTE ഫ്ലാഗ് സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, ഫലം ഇരട്ടി ഉദ്ധരിക്കപ്പെടും
സ്ട്രിംഗിലെ ഏതെങ്കിലും ഇരട്ട ഉദ്ധരണികൾ രക്ഷപ്പെട്ടു. അല്ലെങ്കിൽ PERL_PV_PRETTY_LTGT ആണെങ്കിൽ
ഫ്ലാഗ് സജ്ജീകരിച്ച ശേഷം ഫലം ആംഗിൾ ബ്രാക്കറ്റുകളിൽ പൊതിയുക.

PERL_PV_PRETTY_ELLIPSES ഫ്ലാഗ് സജ്ജീകരിച്ചിരിക്കുകയും സ്‌ട്രിംഗിലെ എല്ലാ പ്രതീകങ്ങളും ഇല്ലെങ്കിൽ
ഔട്ട്പുട്ട് അപ്പോൾ ഒരു ellipsis "..." സ്ട്രിംഗിൽ ചേർക്കും. ഇത് ശ്രദ്ധിക്കുക
അത് ഉദ്ധരിച്ചതിന് ശേഷം സംഭവിക്കുന്നു.

start_color അസാധുവാണെങ്കിൽ, അത് തുറക്കുന്ന ഉദ്ധരണിക്ക് ശേഷം ചേർക്കും (എങ്കിൽ
ഒന്നുണ്ട്) എന്നാൽ രക്ഷപ്പെട്ട വാചകത്തിന് മുമ്പ്. end_color അസാധുവാണെങ്കിൽ അത് ചെയ്യും
രക്ഷപ്പെട്ട ടെക്‌സ്‌റ്റിന് ശേഷം എന്നാൽ ഏതെങ്കിലും ഉദ്ധരണികൾക്കോ ​​ദീർഘവൃത്തങ്ങൾക്കോ ​​മുമ്പായി ചേർക്കുക.

dsv കൈവശം വച്ചിരിക്കുന്ന പ്രെറ്റിഫൈഡ് ടെക്‌സ്‌റ്റിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു.

char* pv_pretty(SV *dsv, char const * const str,
const STRLEN എണ്ണം, const STRLEN പരമാവധി,
char const * const start_color,
char const * const end_color,
const U32 പതാകകൾ)

ഉൾച്ചേർക്കുന്നു പ്രവർത്തനങ്ങൾ

cv_clone
ഒരു സിവി ക്ലോൺ ചെയ്യുക, ഒരു ലെക്സിക്കൽ ക്ലോഷർ ഉണ്ടാക്കുക. പ്രോട്ടോ യുടെ പ്രോട്ടോടൈപ്പ് നൽകുന്നു
പ്രവർത്തനം: അതിന്റെ കോഡ്, പാഡ് ഘടന, മറ്റ് ആട്രിബ്യൂട്ടുകൾ. പ്രോട്ടോടൈപ്പ് ആണ്
കോഡ് സൂചിപ്പിക്കുന്ന ബാഹ്യ ലെക്സിക്കലുകളുടെ ഒരു ക്യാപ്‌ചറുമായി സംയോജിപ്പിച്ചിരിക്കുന്നു, അവ
ഉടനടി ചുറ്റുമുള്ള കോഡിന്റെ നിലവിൽ നടപ്പിലാക്കുന്ന ഉദാഹരണത്തിൽ നിന്ന് എടുത്തത്.

CV * cv_clone(CV * പ്രോട്ടോ)

cv_name പ്രധാനമായും പിശക് റിപ്പോർട്ടിംഗിൽ ഉപയോഗിക്കുന്നതിന് CV യുടെ പേര് അടങ്ങിയ ഒരു SV നൽകുന്നു.
CV യഥാർത്ഥത്തിൽ പകരം ഒരു GV ആയിരിക്കാം, ഈ സാഹചര്യത്തിൽ തിരികെ നൽകിയ SV GV-കൾ കൈവശം വയ്ക്കുന്നു
പേര്. ഒരു ജിവി അല്ലെങ്കിൽ സിവി അല്ലാതെ മറ്റെന്തെങ്കിലും ഇതിനകം കൈവശം വച്ചിരിക്കുന്ന ഒരു സ്ട്രിംഗ് ആയി കണക്കാക്കുന്നു
ഉപനാമം, എന്നാൽ ഇത് ഭാവിയിൽ മാറിയേക്കാം.

രണ്ടാമത്തെ ആർഗ്യുമെന്റായി ഒരു SV പാസ്സാക്കാം. അങ്ങനെയാണെങ്കിൽ, അതിന് പേര് നൽകും
അതു തിരിച്ചു കിട്ടുകയും ചെയ്യും. അല്ലാത്തപക്ഷം തിരിച്ചെത്തിയ എസ്.വി ഒരു പുതിയ മനുഷ്യനായിരിക്കും.

എങ്കില് ഫ്ലാഗുകൾ CV_NAME_NOTQUAL ഉൾപ്പെടുത്തിയാൽ പാക്കേജിന്റെ പേര് ഉൾപ്പെടുത്തില്ല.
ആദ്യത്തെ ആർഗ്യുമെന്റ് ഒരു സിവിയോ ജിവിയോ അല്ലെങ്കിൽ, ഈ ഫ്ലാഗ് അവഗണിക്കപ്പെടും (ഇതിന് വിധേയമായി
മാറ്റം).

SV * cv_name(CV *cv, SV *sv, U32 ഫ്ലാഗുകൾ)

cv_undef
ഒരു സിവിയുടെ എല്ലാ സജീവ ഘടകങ്ങളും മായ്‌ക്കുക. ഇത് ഒന്നുകിൽ സംഭവിക്കാം
വ്യക്തമായ "undef &foo", അല്ലെങ്കിൽ റഫറൻസ് എണ്ണം പൂജ്യത്തിലേക്ക് പോകുന്നു. മുൻകാലങ്ങളിൽ
കേസ്, ഞങ്ങൾ CvOUTSIDE പോയിന്റർ സൂക്ഷിക്കുന്നു, അതുവഴി ഏതൊരു അജ്ഞാത കുട്ടികൾക്കും ഇപ്പോഴും കഴിയും
മുഴുവൻ ലെക്സിക്കൽ സ്കോപ്പ് ചെയിൻ പിന്തുടരുക.

ശൂന്യമായ cv_undef(CV* cv)

find_rundefsv
ന്റെ ലെക്സിക്കൽ സ്കോപ്പിൽ $_ എന്ന് പേരിട്ടിരിക്കുന്ന വേരിയബിൾ കണ്ടെത്തി തിരികെ നൽകുക
നിലവിൽ നിർവ്വഹിക്കുന്ന പ്രവർത്തനം. ഇതൊരു ലെക്സിക്കൽ $_ ആയിരിക്കാം, അല്ലെങ്കിൽ ഇതായിരിക്കും
ആഗോള ഒന്ന്.

SV * find_rundefsv()

find_rundefsvoffset
ഒഴിവാക്കി! പേളിന്റെ ഭാവി റിലീസിൽ നിന്ന് ഈ ഫംഗ്‌ഷൻ നീക്കം ചെയ്യാൻ പദ്ധതിയിട്ടിട്ടുണ്ട്.
പുതിയ കോഡിനായി ഇത് ഉപയോഗിക്കരുത്; നിലവിലുള്ള കോഡിൽ നിന്ന് അത് നീക്കം ചെയ്യുക.

നിലവിൽ നിർവ്വഹിക്കുന്നതിന്റെ പാഡിൽ ലെക്സിക്കൽ $_ ന്റെ സ്ഥാനം കണ്ടെത്തുക
പ്രവർത്തനം. നിലവിലെ പാഡിൽ ഓഫ്‌സെറ്റ് നൽകുന്നു, അല്ലെങ്കിൽ "NOT_IN_PAD" ഇല്ലെങ്കിൽ
ലെക്സിക്കൽ $_ സ്കോപ്പിൽ (ആകയാൽ ഗ്ലോബൽ ഒന്ന് ഉപയോഗിക്കണം).
"find_rundefsv" കൂടുതൽ സൗകര്യപ്രദമായിരിക്കും.

ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷന്റെ perl_ ഫോം ഒഴിവാക്കിയിരിക്കുന്നു.

PADOFFSET find_rundefsvoffset()

ആമുഖം_എന്റെ
ദൃശ്യമായ നിലയിലേക്ക് "എന്റെ" വേരിയബിളുകൾ "അവതരിപ്പിക്കുക". പാഴ്‌സിംഗ് സമയത്ത് ഇതിനെ വിളിക്കുന്നു
ഓരോ പ്രസ്താവനയുടെയും അവസാനം ലെക്സിക്കൽ വേരിയബിളുകൾ തുടർന്നുള്ളവയ്ക്ക് ദൃശ്യമാക്കും
പ്രസ്താവനകൾ.

U32 intro_my()

ലോഡ്_മൊഡ്യൂൾ
പേരിന്റെ സ്ട്രിംഗ് ഭാഗം കൊണ്ട് പേര് സൂചിപ്പിച്ചിരിക്കുന്ന മൊഡ്യൂൾ ലോഡ് ചെയ്യുന്നു. അതല്ല
യഥാർത്ഥ മൊഡ്യൂളിന്റെ പേര് നൽകണം, ഫയലിന്റെ പേരല്ല. ഉദാ, പകരം "Foo::Bar"
"Foo/Bar.pm" എന്നതിന്റെ. ഫ്ലാഗുകൾ PERL_LOADMOD_DENY, PERL_LOADMOD_NOIMPORT, അല്ലെങ്കിൽ
PERL_LOADMOD_IMPORT_OPS (അല്ലെങ്കിൽ ഫ്ലാഗുകൾ ഇല്ലാത്തതിന് 0). ver, വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിലും NULL അല്ല,
"Foo::Bar VERSION ഉപയോഗിക്കുക" എന്നതിന് സമാനമായ പതിപ്പ് സെമാന്റിക്സ് നൽകുന്നു. ഓപ്ഷണൽ
മൊഡ്യൂളിലേക്ക് ആർഗ്യുമെന്റുകൾ വ്യക്തമാക്കാൻ trailing SV* ആർഗ്യുമെന്റുകൾ ഉപയോഗിക്കാം ഇറക്കുമതി()
"Foo::Bar VERSION LIST ഉപയോഗിക്കുക" എന്നതിന് സമാനമായ രീതി. അവ എ ഉപയോഗിച്ച് അവസാനിപ്പിക്കണം
അവസാന NULL പോയിന്റർ. എപ്പോൾ മാത്രമേ ഈ ലിസ്റ്റ് ഒഴിവാക്കാനാകൂ എന്നത് ശ്രദ്ധിക്കുക
PERL_LOADMOD_NOIMPORT ഫ്ലാഗ് ഉപയോഗിച്ചു. അല്ലെങ്കിൽ ഒരു NULL എങ്കിലും
ഡിഫോൾട്ട് ഇമ്പോർട്ട് ലിസ്റ്റ് നിർദ്ദേശിക്കാൻ പോയിന്റർ ആവശ്യമാണ്.

ഓരോ നിർദ്ദിഷ്‌ട "SV*" പാരാമീറ്ററിന്റെയും റഫറൻസ് എണ്ണം കുറയുന്നു.

void load_module(U32 ഫ്ലാഗുകൾ, SV* പേര്, SV* ver, ...)

പുതിയPADNAMELIST
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു പുതിയ പാഡ് നെയിം ലിസ്റ്റ് സൃഷ്ടിക്കുന്നു. "max" എന്നത് സ്പേസ് ഉള്ള ഏറ്റവും ഉയർന്ന സൂചികയാണ്
അനുവദിച്ചു.

PADNAMELIST * newPADNAMELIST(പരമാവധി_t)

പുതിയPADNAMEouter
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു പുതിയ പാഡ് നാമം നിർമ്മിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു. പേരുകൾക്ക് മാത്രം ഈ ഫംഗ്ഷൻ ഉപയോഗിക്കുക
ബാഹ്യ ലെക്സിക്കലുകളെ പരാമർശിക്കുക. ("newPADNAMEpvn" എന്നതും കാണുക.) പുറം പുറം പാഡ് നാമമാണ്
ഇത് കണ്ണാടിയാണെന്ന്. തിരികെ നൽകിയ പാഡ് നാമത്തിൽ ഇതിനകം തന്നെ PADNAMEt_OUTER ഫ്ലാഗ് ഉണ്ട്
സജ്ജമാക്കുക.

PADNAME * newPADNAMEouter(PADNAME *outer)

പുതിയPADNAMEpvn
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു പുതിയ പാഡ് നാമം നിർമ്മിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു. s ഒരു UTF8 സ്ട്രിംഗ് ആയിരിക്കണം. ഇത് ഉപയോഗിക്കരുത്
ബാഹ്യ ലെക്സിക്കലുകളിലേക്ക് വിരൽ ചൂണ്ടുന്ന പാഡ് പേരുകൾക്കായി. "newPADNAMEouter" കാണുക.

PADNAME * newPADNAMEpvn(const char *s, STRLEN ലെൻ)

nothreadhook
ത്രെഡുകളില്ലാത്തപ്പോൾ perl_destruct-ന് ത്രെഡ് ഹുക്ക് നൽകുന്ന അപൂർണ്ണം.

int nothreadhook()

padnamelist_fetch
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

തന്നിരിക്കുന്ന സൂചികയിൽ നിന്ന് പാഡ് നാമം ലഭ്യമാക്കുന്നു.

PADNAME * padnamelist_fetch(PADNAMELIST *pnl,
SSize_t കീ)

പാഡ്‌നാമലിസ്റ്റ്_സ്റ്റോർ
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

നൽകിയിരിക്കുന്ന സൂചികയിൽ പാഡ് നാമം സംഭരിക്കുന്നു (അത് അസാധുവായിരിക്കാം), നിലവിലുള്ളവയെ സ്വതന്ത്രമാക്കുന്നു
ആ സ്ലോട്ടിൽ പാഡ് നാമം.

PADNAME ** padnamelist_store(PADNAMELIST *pnl,
SSize_t കീ, PADNAME *val)

pad_add_anon
നിലവിൽ കംപൈൽ ചെയ്യുന്ന പാഡിൽ ("pad_alloc" വഴി) ഒരു സ്ഥലം അനുവദിക്കുന്നു
നിലവിൽ കംപൈലിങ്ങിനുള്ളിൽ ലെക്സിക്കലി സ്കോപ്പ് ചെയ്തിരിക്കുന്ന അജ്ഞാത ഫംഗ്ഷൻ
പ്രവർത്തനം. ചടങ്ങ് ഫങ്ക് പാഡിലേക്കും അതിന്റെ "CvOUTSIDE" ലിങ്കിലേക്കും ലിങ്ക് ചെയ്‌തിരിക്കുന്നു
ഒരു റഫറൻസ് ലൂപ്പ് ഒഴിവാക്കാൻ ബാഹ്യ സ്കോപ്പ് ദുർബലമാണ്.

ഒരു റഫറൻസ് എണ്ണം മോഷ്ടിക്കപ്പെട്ടതിനാൽ നിങ്ങൾ "SvREFCNT_inc(func)" ചെയ്യേണ്ടതുണ്ട്.

ഒപ്ടൈപ്പ് പാഡ് എൻട്രി ഏത് തരത്തിലുള്ള പ്രവർത്തനമാണെന്ന് സൂചിപ്പിക്കുന്ന ഒരു ഒപ്കോഡ് ആയിരിക്കണം
പിന്തുണയ്ക്കാന്. ഇത് പ്രവർത്തന സെമാന്റിക്സിനെ ബാധിക്കില്ല, പക്ഷേ ഡീബഗ്ഗിംഗിനായി ഉപയോഗിക്കുന്നു.

PADOFFSET pad_add_anon(CV *func, I32 optype)

pad_add_name_pv
കൃത്യമായി "pad_add_name_pvn" പോലെയാണ്, എന്നാൽ a ന് പകരം nul-terminated string എടുക്കുന്നു
സ്ട്രിംഗ്/നീളം ജോടി.

PADOFFSET pad_add_name_pv(const char *name, U32 ഫ്ലാഗുകൾ,
HV *typestash, HV *ourstash)

pad_add_name_pvn
പേരുള്ള ഒരു ലെക്സിക്കൽ വേരിയബിളിനായി നിലവിൽ കംപൈൽ ചെയ്യുന്ന പാഡിൽ ഒരു സ്ഥലം അനുവദിക്കുന്നു.
പാഡിന്റെ പേരിൽ നാമവും മറ്റ് മെറ്റാഡാറ്റയും സംഭരിക്കുകയും നിർമ്മിക്കുകയും ചെയ്യുന്നു
വേരിയബിളിന്റെ ലെക്സിക്കൽ സ്കോപ്പിംഗ് നിയന്ത്രിക്കാനുള്ള തയ്യാറെടുപ്പുകൾ. യുടെ ഓഫ്‌സെറ്റ് നൽകുന്നു
അനുവദിച്ച പാഡ് സ്ലോട്ട്.

namepv/പേര് പ്രമുഖ സിഗിൽ ഉൾപ്പെടെ വേരിയബിളിന്റെ പേര് വ്യക്തമാക്കുക. എങ്കിൽ ടൈപ്പ്സ്റ്റാഷ്
അസാധുവാണ്, പേര് ടൈപ്പ് ചെയ്ത ലെക്സിക്കലിനുള്ളതാണ്, ഇത് തരം തിരിച്ചറിയുന്നു. എങ്കിൽ
നമ്മുടെ സ്റ്റാഷ് അസാധുവാണ്, ഇത് ഒരു പാക്കേജ് വേരിയബിളിനുള്ള ഒരു ലെക്സിക്കൽ റഫറൻസാണ്, ഇതും
പാക്കേജ് തിരിച്ചറിയുന്നു. ഇനിപ്പറയുന്ന ഫ്ലാഗുകൾ ഒരുമിച്ച് ചേർക്കാം:

padadd_OUR അത് ഒരു പാക്കേജ് var ആണെങ്കിൽ അനാവശ്യമായി വ്യക്തമാക്കുന്നു
padadd_STATE വേരിയബിൾ മൂല്യം സ്ഥിരമായി നിലനിർത്തും
padadd_NO_DUP_CHECK ലെക്സിക്കൽ ഷാഡോവിങ്ങിനായി പരിശോധിക്കുന്നത് ഒഴിവാക്കുക

PADOFFSET pad_add_name_pvn(const char *namepv,
STRLEN നാമലെൻ, U32 പതാകകൾ,
HV *typestash, HV *ourstash)

pad_add_name_sv
കൃത്യമായി "pad_add_name_pvn" പോലെ, എന്നാൽ ഒരു SV രൂപത്തിൽ പേര് സ്ട്രിംഗ് എടുക്കുന്നു
ഒരു സ്ട്രിംഗ്/നീളമുള്ള ജോഡിക്ക് പകരം.

PADOFFSET pad_add_name_sv(SV *പേര്, U32 ഫ്ലാഗുകൾ,
HV *typestash, HV *ourstash)

pad_alloc
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

നിലവിൽ കംപൈൽ ചെയ്യുന്ന പാഡിൽ ഒരു സ്ഥലം അനുവദിക്കുകയും, ഓഫ്‌സെറ്റ് തിരികെ നൽകുകയും ചെയ്യുന്നു
അനുവദിച്ച പാഡ് സ്ലോട്ട്. പാഡ് സ്ലോട്ടിൽ തുടക്കത്തിൽ പേരൊന്നും ചേർത്തിട്ടില്ല. tmptype ഒരു ആണ്
ഏത് തരത്തിലുള്ള പാഡ് എൻട്രി ആവശ്യമാണെന്ന് സൂചിപ്പിക്കുന്ന ഫ്ലാഗുകളുടെ ഒരു കൂട്ടം, അവയിൽ സജ്ജീകരിക്കും
അനുവദിച്ച പാഡ് എൻട്രിക്കുള്ള മൂല്യം SV:

SVs_PADMY എന്ന ലെക്സിക്കൽ വേരിയബിൾ ("എന്റെ", "ഞങ്ങളുടെ", "സംസ്ഥാനം")
SVs_PADTMP പേരിടാത്ത താൽക്കാലിക സ്റ്റോർ
റിക്കർഷൻ ലെവലുകൾക്കിടയിൽ SVf_READONLY സ്ഥിരമായി പങ്കിടുന്നു

"SVf_READONLY" ഇവിടെ perl 5.20 മുതൽ പിന്തുണയ്ക്കുന്നു. നേരത്തെ പ്രവർത്തിക്കാൻ
പതിപ്പുകളും, "SVf_READONLY|SVs_PADTMP" ഉപയോഗിക്കുക. "SVf_READONLY" കാരണമാകില്ല
പാഡ് സ്ലോട്ടിലെ എസ്വി വായിക്കാൻ മാത്രമായി അടയാളപ്പെടുത്തണം, പക്ഷേ "pad_alloc" എന്ന് ലളിതമായി പറയുന്നു
it ഉദ്ദേശിക്കുന്ന (കോളർ മുഖേന) വായിക്കാൻ മാത്രമുള്ളതാക്കുക, അല്ലെങ്കിൽ കുറഞ്ഞത് അത്തരത്തിലെങ്കിലും പരിഗണിക്കണം.

ഒപ്ടൈപ്പ് പാഡ് എൻട്രി ഏത് തരത്തിലുള്ള പ്രവർത്തനമാണെന്ന് സൂചിപ്പിക്കുന്ന ഒരു ഒപ്കോഡ് ആയിരിക്കണം
പിന്തുണയ്ക്കാന്. ഇത് പ്രവർത്തന സെമാന്റിക്സിനെ ബാധിക്കില്ല, പക്ഷേ ഡീബഗ്ഗിംഗിനായി ഉപയോഗിക്കുന്നു.

PADOFFSET pad_alloc(I32 optype, U32 tmptype)

pad_findmy_pv
കൃത്യമായി "pad_findmy_pvn" പോലെയാണ്, എന്നാൽ a ന് പകരം ഒരു nul-terminated string എടുക്കുന്നു
സ്ട്രിംഗ്/നീളം ജോടി.

PADOFFSET pad_findmy_pv(const char *name, U32 ഫ്ലാഗുകൾ)

pad_findmy_pvn
ഒരു ലെക്സിക്കൽ വേരിയബിളിന്റെ പേര് നൽകിയാൽ, നിലവിലുള്ള കംപൈലിംഗിൽ അതിന്റെ സ്ഥാനം കണ്ടെത്തുക
പാഡ്. namepv/പേര് ലീഡിംഗ് സിഗിൽ ഉൾപ്പെടെ വേരിയബിളിന്റെ പേര് വ്യക്തമാക്കുക. ഫ്ലാഗുകൾ
നിക്ഷിപ്തമാണ്, പൂജ്യമായിരിക്കണം. അത് നിലവിലെ പാഡിൽ ഇല്ലെങ്കിലും ദൃശ്യമാകുകയാണെങ്കിൽ
ഏതെങ്കിലും ലെക്സിക്കലി എൻക്ലോസിംഗ് സ്കോപ്പിന്റെ പാഡ്, അതിനുശേഷം അതിനുള്ള ഒരു കപട എൻട്രി ചേർക്കുന്നു
നിലവിലെ പാഡ്. നിലവിലെ പാഡിൽ ഓഫ്‌സെറ്റ് നൽകുന്നു, അല്ലെങ്കിൽ അതല്ലെങ്കിൽ "NOT_IN_PAD"
ലെക്സിക്കൽ പരിധിയിലാണ്.

PADOFFSET pad_findmy_pvn(const char *namepv,
STRLEN നാമലെൻ, U32 പതാകകൾ)

pad_findmy_sv
കൃത്യമായി "pad_findmy_pvn" പോലെ, എന്നാൽ ഒരു SV രൂപത്തിൽ പേര് സ്ട്രിംഗ് എടുക്കുന്നു
ഒരു സ്ട്രിംഗ്/നീളമുള്ള ജോഡിക്ക് പകരം.

PADOFFSET pad_findmy_sv(SV *പേര്, U32 ഫ്ലാഗുകൾ)

pad_setv
ഓഫ്‌സെറ്റിൽ മൂല്യം സജ്ജമാക്കുക po നിലവിലുള്ള (കംപൈലിംഗ് അല്ലെങ്കിൽ എക്സിക്യൂട്ടിംഗ്) പാഡിൽ. ഉപയോഗിക്കുക
മാക്രോ PAD_SETSV() ഈ ഫംഗ്‌ഷൻ നേരിട്ട് വിളിക്കുന്നതിനുപകരം.

void pad_setsv(PADOFFSET po, SV *sv)

pad_sv ഓഫ്‌സെറ്റിൽ മൂല്യം നേടുക po നിലവിലുള്ള (കംപൈലിംഗ് അല്ലെങ്കിൽ എക്സിക്യൂട്ടിംഗ്) പാഡിൽ. മാക്രോ ഉപയോഗിക്കുക
ഈ ഫംഗ്‌ഷൻ നേരിട്ട് വിളിക്കുന്നതിന് പകരം PAD_SV.

SV * pad_sv(PADOFFSET പോ)

തടം_വൃത്തിയായി
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

കോഡിന്റെ സമാഹാരത്തിന്റെ അവസാനം ഒരു പാഡ് വൃത്തിയാക്കുക. ജോലികൾ
ഇവിടെ നടപ്പിലാക്കുന്നത്: അനോൺസബ് പ്രോട്ടോടൈപ്പുകളുടെ പാഡുകളിൽ നിന്ന് മിക്ക കാര്യങ്ങളും നീക്കം ചെയ്യുക; തരൂ
ഒരു @_; താൽക്കാലികക്കാരെ അങ്ങനെ അടയാളപ്പെടുത്തുക. ടൈപ്പ് ചെയ്യുക സബ്റൂട്ടിൻ തരം സൂചിപ്പിക്കുന്നു:

padtidy_SUB സാധാരണ സബ്റൂട്ടീൻ
padtidy_SUBCLONE ലെക്സിക്കൽ ക്ലോഷറിനുള്ള പ്രോട്ടോടൈപ്പ്
padtidy_FORMAT ഫോർമാറ്റ്

ശൂന്യമായ pad_tidy(padtidy_type തരം)

perl_alloc
ഒരു പുതിയ Perl വ്യാഖ്യാതാവിനെ അനുവദിക്കുന്നു. പെർലെംബെഡ് കാണുക.

PerlInterpreter* perl_alloc()

perl_confirst
ഒരു പുതിയ പേൾ ഇന്റർപ്രെറ്റർ ആരംഭിക്കുന്നു. പെർലെംബെഡ് കാണുക.

void perl_confirl (PerlInterpreter *my_perl)

perl_destruct
ഒരു പേൾ ഇന്റർപ്രെറ്റർ ഷട്ട് ഡൗൺ ചെയ്യുന്നു. പെർലെംബെഡ് കാണുക.

int perl_destruct(PerlInterpreter *my_perl)

perl_free
ഒരു പേൾ ഇന്റർപ്രെറ്റർ പുറത്തിറക്കുന്നു. പെർലെംബെഡ് കാണുക.

void perl_free(PerlInterpreter *my_perl)

perl_parse
ഒരു പേൾ സ്ക്രിപ്റ്റ് പാഴ്സ് ചെയ്യാൻ ഒരു പേൾ ഇന്റർപ്രെറ്ററോട് പറയുന്നു. പെർലെംബെഡ് കാണുക.

int perl_parse(PerlInterpreter *my_perl,
XSINIT_t xsinit, int argc,
char** argv, char** env)

perl_run
ഒരു പേൾ ഇന്റർപ്രെറ്ററോട് പ്രവർത്തിക്കാൻ പറയുന്നു. പെർലെംബെഡ് കാണുക.

int perl_run(PerlInterpreter *my_perl)

ആവശ്യം_pv
സ്ട്രിംഗ് ആർഗ്യുമെന്റ് പേരിട്ടിരിക്കുന്ന ഫയൽ "ആവശ്യമാണ്" എന്ന് Perl-നോട് പറയുന്നു. ഇതിന് സമാനമാണ്
പേൾ കോഡ് "eval "require '$file'"". അത് ആ വിധത്തിലാണ് നടപ്പിലാക്കിയിരിക്കുന്നത്; പരിഗണിക്കുക
പകരം load_module ഉപയോഗിക്കുന്നു.

ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷന്റെ perl_ ഫോം ഒഴിവാക്കിയിരിക്കുന്നു.

അസാധുവാണ് ആവശ്യം_പിവി(കോൺസ്റ്റ് ചാർ* പിവി)

ഒഴിവാക്കൽ കൈകാര്യം (ലളിതമായ) മാക്രോകൾ

dXCPT ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യുന്നതിനായി ആവശ്യമായ ലോക്കൽ വേരിയബിളുകൾ സജ്ജമാക്കുക. "ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യൽ" കാണുക
perlguts ൽ.

dXCPT;

XCPT_CATCH
ഒരു ക്യാച്ച് ബ്ലോക്ക് അവതരിപ്പിക്കുന്നു. perlguts-ൽ "ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യൽ" കാണുക.

XCPT_RETHROW
മുമ്പ് പിടിക്കപ്പെട്ട ഒരു അപവാദം തിരിച്ചെടുക്കുന്നു. perlguts-ൽ "ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യൽ" കാണുക.

XCPT_RETHROW;

XCPT_TRY_END
ഒരു ട്രൈ ബ്ലോക്ക് അവസാനിക്കുന്നു. perlguts-ൽ "ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യൽ" കാണുക.

XCPT_TRY_START
ഒരു ട്രൈ ബ്ലോക്ക് ആരംഭിക്കുന്നു. perlguts-ൽ "ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യൽ" കാണുക.

ആഗോള വേരിയബിളുകൾ

ഈ വേരിയബിളുകൾ ഒരു മുഴുവൻ പ്രക്രിയയ്ക്കും ആഗോളമാണ്. അവ എല്ലാ വ്യാഖ്യാതാക്കൾക്കുമിടയിൽ പങ്കിടുന്നു
ഒരു പ്രക്രിയയിലെ എല്ലാ ത്രെഡുകളും.

PL_ചെക്ക്
"ചെക്ക്" ഘട്ടത്തിനായി വിളിക്കപ്പെടുന്ന ഫംഗ്‌ഷനുകളുടെ ഓപ്‌കോഡ് സൂചികയിലാക്കിയ അറേ
പേൾ കോഡ് സമാഹരിക്കുന്ന സമയത്ത് ഒപ്ട്രീ കെട്ടിടത്തിന്റെ. മിക്ക (എല്ലാം അല്ല) തരങ്ങൾക്കും
ഓപ്പിന്റെ, തുടക്കത്തിൽ ഓപ് നിർമ്മിച്ച് ചൈൽഡ് ഓപ്‌സ് ഉള്ളപ്പോൾ അത് ചെയ്യും
ഉചിതമായ ഘടകം റഫറൻസ് ചെയ്ത ചെക്ക് ഫംഗ്ഷനിലൂടെ ഫിൽട്ടർ ചെയ്യപ്പെടും
ഈ അറേ. ചെക്ക് ഫംഗ്‌ഷനിലേക്കുള്ള ഏക ആർഗ്യുമെന്റായി പുതിയ ഓപ്‌ കടന്നുപോകുന്നു,
കൂടാതെ ചെക്ക് ഫംഗ്‌ഷൻ പൂർത്തിയാക്കിയ op തിരികെ നൽകുന്നു. ചെക്ക് ഫംഗ്ഷൻ ചെയ്യാം (ഇത് പോലെ
പേര് നിർദ്ദേശിക്കുന്നു) സാധുതയ്ക്കും സിഗ്നൽ പിശകുകൾക്കുമായി op പരിശോധിക്കുക. അതും ആകാം
ഓപ്‌സിന്റെ ഭാഗങ്ങൾ ആരംഭിക്കുക അല്ലെങ്കിൽ പരിഷ്‌ക്കരിക്കുക, അല്ലെങ്കിൽ കൂടുതൽ സമൂലമായ ശസ്ത്രക്രിയകൾ നടത്തുക
ചൈൽഡ് ഓപ്‌സ് ചേർക്കുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യുക, അല്ലെങ്കിൽ ഓപ് എറിഞ്ഞിട്ട് മറ്റൊരു ഓപ്‌സ് തിരികെ നൽകുക
അതിന്റെ സ്ഥാനത്ത്.

ഫംഗ്‌ഷൻ പോയിന്ററുകളുടെ ഈ ശ്രേണി സമാഹാരത്തിലേക്ക് ഹുക്ക് ചെയ്യുന്നതിനുള്ള സൗകര്യപ്രദമായ സ്ഥലമാണ്
പ്രക്രിയ. ഒരു XS മൊഡ്യൂളിന് അതിന്റെ ഏതെങ്കിലും ഇഷ്‌ടാനുസൃത പരിശോധന പ്രവർത്തനം സ്ഥാപിക്കാൻ കഴിയും
ഒരു പ്രത്യേക തരം ഒപിയുടെ സമാഹാരത്തെ സ്വാധീനിക്കാൻ സ്റ്റാൻഡേർഡ് ആയവ.
എന്നിരുന്നാലും, ഒരു ഇഷ്‌ടാനുസൃത ചെക്ക് ഫംഗ്‌ഷൻ ഒരിക്കലും ഒരു സാധാരണ ചെക്ക് പൂർണ്ണമായും മാറ്റിസ്ഥാപിക്കരുത്
ഫംഗ്‌ഷൻ (അല്ലെങ്കിൽ മറ്റൊരു മൊഡ്യൂളിൽ നിന്നുള്ള ഒരു കസ്റ്റം ചെക്ക് ഫംഗ്‌ഷൻ പോലും). ഒരു മൊഡ്യൂൾ
പകരം പരിശോധന പരിഷ്കരിക്കണം പൊതിയുക നിലവിലുള്ള ചെക്ക് ഫംഗ്ഷൻ. ഒരു ആചാരം
ചെക്ക് ഫംഗ്‌ഷൻ അതിന്റെ ഇഷ്‌ടാനുസൃത പെരുമാറ്റം എപ്പോൾ പ്രയോഗിക്കണം എന്നതിനെക്കുറിച്ച് തിരഞ്ഞെടുത്തിരിക്കണം. ൽ
ഒരു OP ഉപയോഗിച്ച് പ്രത്യേകമായി ഒന്നും ചെയ്യേണ്ടതില്ലെന്ന് തീരുമാനിക്കുന്ന സാധാരണ കേസ്, അത് ചങ്ങലയിലായിരിക്കണം
നിലവിലുള്ള op ഫംഗ്‌ഷൻ. ചെക്ക് ഫംഗ്‌ഷനുകൾ ഇങ്ങനെ ഒരു ശൃംഖലയിൽ ബന്ധിപ്പിച്ചിരിക്കുന്നു
അവസാനം കോറിന്റെ അടിസ്ഥാന ചെക്കർ.

ത്രെഡ് സുരക്ഷയ്ക്കായി, മൊഡ്യൂളുകൾ ഈ അറേയിലേക്ക് നേരിട്ട് എഴുതരുത്. പകരം, ഉപയോഗിക്കുക
"wrap_op_checker" എന്ന പ്രവർത്തനം.

PL_keyword_plugin
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഫംഗ്ഷൻ പോയിന്റർ, വിപുലീകൃത കീവേഡുകൾ കൈകാര്യം ചെയ്യാൻ ഉപയോഗിക്കുന്ന ഒരു ഫംഗ്ഷനിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്നു. ദി
ഫംഗ്‌ഷൻ ആയി പ്രഖ്യാപിക്കണം

int keyword_plugin_function(pTHX_
char *keyword_ptr, STRLEN കീവേഡ്_ലെൻ,
OP **op_ptr)

സാധ്യമായ ഒരു കീവേഡ് കാണുമ്പോഴെല്ലാം, ടോക്കനൈസറിൽ നിന്നാണ് ഫംഗ്‌ഷൻ വിളിക്കുന്നത്.
"keyword_ptr" പാഴ്‌സറിന്റെ ഇൻപുട്ട് ബഫറിലെ പദത്തിലും "keyword_len" എന്നതിലും പോയിന്റ് ചെയ്യുന്നു
അതിന്റെ നീളം നൽകുന്നു; അത് അസാധുവാക്കിയിട്ടില്ല. പ്രവർത്തനം പരിശോധിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നു
വാക്ക്, %^H പോലെയുള്ള മറ്റ് അവസ്ഥകൾ, അത് വേണോ എന്ന് തീരുമാനിക്കാൻ
ഒരു വിപുലീകൃത കീവേഡ് ആയി കൈകാര്യം ചെയ്യുക. ഇല്ലെങ്കിൽ, ഫംഗ്ഷൻ തിരികെ നൽകണം
"KEYWORD_PLUGIN_DECLINE", കൂടാതെ സാധാരണ പാഴ്സർ പ്രക്രിയ തുടരും.

ഫംഗ്‌ഷന് കീവേഡ് കൈകാര്യം ചെയ്യണമെങ്കിൽ, അത് ആദ്യം എന്തും പാഴ്‌സ് ചെയ്യണം
കീവേഡ് അവതരിപ്പിച്ച വാക്യഘടനയുടെ ഭാഗമായ കീവേഡ് പിന്തുടരുന്നു. കാണുക
വിശദാംശങ്ങൾക്ക് "ലെക്സർ ഇന്റർഫേസ്".

ഒരു കീവേഡ് കൈകാര്യം ചെയ്യുമ്പോൾ, പ്ലഗിൻ ഫംഗ്‌ഷൻ "OP" ന്റെ ഒരു ട്രീ നിർമ്മിക്കണം.
ഘടനകൾ, പാഴ്‌സ് ചെയ്‌ത കോഡിനെ പ്രതിനിധീകരിക്കുന്നു. മരത്തിന്റെ വേര് ആയിരിക്കണം
*op_ptr-ൽ സംഭരിച്ചിരിക്കുന്നു. ഫംഗ്ഷൻ പിന്നീട് വാക്യഘടനയെ സൂചിപ്പിക്കുന്ന സ്ഥിരാങ്കം നൽകുന്നു
അത് പാഴ്‌സ് ചെയ്‌ത നിർമ്മാണത്തിന്റെ പങ്ക്: "KEYWORD_PLUGIN_STMT" ആണെങ്കിൽ
പൂർണ്ണമായ പ്രസ്താവന, അല്ലെങ്കിൽ അത് ഒരു പദപ്രയോഗമാണെങ്കിൽ "KEYWORD_PLUGIN_EXPR". എ എന്നത് ശ്രദ്ധിക്കുക
ഒരു എക്‌സ്‌പ്രഷനിൽ സ്റ്റേറ്റ്‌മെന്റ് കൺസ്ട്രക്‌റ്റ് ഉപയോഗിക്കാൻ കഴിയില്ല ("ബ്ലോക്ക് ചെയ്യുക" വഴി ഒഴികെ
സമാനമായത്), കൂടാതെ ഒരു പദപ്രയോഗം ഒരു പൂർണ്ണമായ പ്രസ്താവനയല്ല (അതിന് കുറഞ്ഞത് ഒരു ആവശ്യമാണ്
അർദ്ധവിരാമം അവസാനിപ്പിക്കുന്നു).

ഒരു കീവേഡ് കൈകാര്യം ചെയ്യുമ്പോൾ, പ്ലഗിൻ ഫംഗ്‌ഷനും (കംപൈൽ-ടൈം) സൈഡ് ഉണ്ടായിരിക്കാം
ഇഫക്റ്റുകൾ. ഇത് "%^H" പരിഷ്കരിച്ചേക്കാം, ഫംഗ്ഷനുകൾ നിർവചിക്കുക തുടങ്ങിയവ. സാധാരണയായി, സൈഡ് ആണെങ്കിൽ
ഒരു ഹാൻഡ്‌ലറിന്റെ പ്രധാന ഉദ്ദേശം ഇഫക്റ്റുകളാണ്, അതിനുള്ള ഓപ്‌സുകളൊന്നും സൃഷ്ടിക്കാൻ അത് ആഗ്രഹിക്കുന്നില്ല
സാധാരണ സമാഹാരത്തിൽ ഉൾപ്പെടുത്തണം. ഈ സാഹചര്യത്തിൽ, അത് ഇപ്പോഴും ആവശ്യമാണ്
ഒരു ഓപ് ട്രീ നൽകുക, പക്ഷേ ഒരൊറ്റ നൾ ഓപ് സൃഷ്ടിക്കാൻ ഇത് മതിയാകും.

അങ്ങനെയാണ് *PL_keyword_plugin ഫംഗ്‌ഷൻ മൊത്തത്തിൽ പ്രവർത്തിക്കേണ്ടത്.
എന്നിരുന്നാലും, പരമ്പരാഗതമായി, നിലവിലുള്ള ഹാൻഡ്‌ലറിനെ ഒരാൾ പൂർണ്ണമായും മാറ്റിസ്ഥാപിക്കുന്നില്ല
പ്രവർത്തനം. പകരം, നിങ്ങളുടേത് അസൈൻ ചെയ്യുന്നതിന് മുമ്പ് "PL_keyword_plugin" ന്റെ ഒരു പകർപ്പ് എടുക്കുക
അതിലേക്കുള്ള ഫംഗ്ഷൻ പോയിന്റർ. നിങ്ങളുടെ ഹാൻഡ്‌ലർ ഫംഗ്‌ഷൻ കീവേഡുകൾക്കായി നോക്കണം
അവയിൽ താൽപ്പര്യം പ്രകടിപ്പിക്കുകയും കൈകാര്യം ചെയ്യുകയും ചെയ്യുക. താൽപ്പര്യമില്ലാത്തിടത്ത്, അത് വിളിക്കണം
സംരക്ഷിച്ച പ്ലഗിൻ ഫംഗ്‌ഷൻ, അതിന് ലഭിച്ച ആർഗ്യുമെന്റുകൾ കൈമാറുന്നു. അങ്ങനെ
"PL_keyword_plugin" യഥാർത്ഥത്തിൽ ഹാൻഡ്‌ലർ ഫംഗ്‌ഷനുകളുടെ ഒരു ശൃംഖലയെ സൂചിപ്പിക്കുന്നു, ഇവയെല്ലാം
കീവേഡുകൾ കൈകാര്യം ചെയ്യാനുള്ള അവസരമുണ്ട്, ശൃംഖലയിലെ അവസാന പ്രവർത്തനം മാത്രം
(Perl core-ൽ നിർമ്മിച്ചത്) സാധാരണയായി "KEYWORD_PLUGIN_DECLINE" തിരികെ നൽകും.

GV പ്രവർത്തനങ്ങൾ

ഒരു GV എന്നത് ഒരു Perl ടൈപ്പ്ഗ്ലോബിനോട് യോജിക്കുന്ന ഒരു ഘടനയാണ്, അതായത് *foo. അതൊരു ഘടനയാണ്
$foo, @foo, %foo എന്നിവയുമായി ബന്ധപ്പെട്ട ഒരു സ്കെയിലർ, ഒരു അറേ, ഒരു ഹാഷ് മുതലായവയിലേക്ക് ഒരു പോയിന്റർ പിടിക്കുന്നു.

പേൾ സംഭരിക്കുന്ന സ്റ്റാഷുകളിൽ (സിംബൽ ടേബിൾ ഹാഷുകൾ) ജിവികൾ സാധാരണയായി മൂല്യങ്ങളായി കാണപ്പെടുന്നു.
ആഗോള വേരിയബിളുകൾ.

GvAV GV-ൽ നിന്ന് AV തിരികെ നൽകുക.

AV* GvAV(GV* gv)

GvCV GV-യിൽ നിന്ന് CV തിരികെ നൽകുക.

CV* GvCV(GV* gv)

GvHV GV-ൽ നിന്ന് HV തിരികെ നൽകുക.

HV* GvHV(GV* gv)

GvSV GV-യിൽ നിന്ന് SV തിരികെ നൽകുക.

SV* GvSV(GV* gv)

gv_const_sv
"gv" എന്നത് ഒരു ടൈപ്പ്ഗ്ലോബ് ആണെങ്കിൽ, അതിന്റെ സബ്റൂട്ടീൻ എൻട്രി ഒരു സ്ഥിരമായ ഉപയാണ്.
ഇൻലൈനിംഗ്, അല്ലെങ്കിൽ "gv" എന്നത് അത്തരത്തിലുള്ള ഒരു പ്ലെയ്‌സ്‌ഹോൾഡർ റഫറൻസാണ്
typeglob, തുടർന്ന് സബ് നൽകിയ മൂല്യം നൽകുന്നു. അല്ലെങ്കിൽ, NULL നൽകുന്നു.

SV* gv_const_sv(GV* gv)

gv_fetchmeth
"gv_fetchmeth_pvn" പോലെ, എന്നാൽ ഒരു ഫ്ലാഗ് പാരാമീറ്റർ ഇല്ല.

GV* gv_fetchmeth(HV* സ്റ്റാഷ്, കോൺസ്റ്റ് ചാർ* പേര്,
STRLEN ലെൻ, I32 ലെവൽ)

gv_fetchmethod_autoload
എന്നതിലെ രീതി അഭ്യർത്ഥിക്കുന്നതിന് വിളിക്കേണ്ട സബ്റൂട്ടീൻ അടങ്ങുന്ന ഗ്ലോബ് നൽകുന്നു
"സ്റ്റാഷ്". വാസ്തവത്തിൽ ഓട്ടോലോഡിംഗിന്റെ സാന്നിധ്യത്തിൽ ഇത് ഗ്ലോബ് ആയിരിക്കാം
"ഓട്ടോലോഡ്". ഈ സാഹചര്യത്തിൽ $AUTOLOAD എന്ന അനുബന്ധ വേരിയബിൾ ഇതിനകം സജ്ജീകരിച്ചിരിക്കുന്നു.

"gv_fetchmethod_autoload" എന്നതിന്റെ മൂന്നാമത്തെ പരാമീറ്റർ AUTOLOAD എന്ന് നിർണ്ണയിക്കുന്നു
നൽകിയിരിക്കുന്ന രീതി നിലവിലില്ലെങ്കിൽ ലുക്ക്അപ്പ് നടത്തുന്നു: പൂജ്യം അല്ലാത്തത് അതെ, നോക്കുക എന്നാണ്
ഓട്ടോലോഡിനായി; പൂജ്യം അർത്ഥമാക്കുന്നത് ഇല്ല, ഓട്ടോലോഡിനായി നോക്കരുത്. "gv_fetchmethod" എന്നാണ് വിളിക്കുന്നത്
പൂജ്യമല്ലാത്ത "ഓട്ടോലോഡ്" ഉപയോഗിച്ച് "gv_fetchmethod_autoload" എന്ന് വിളിക്കുന്നതിന് തുല്യമാണ്
പാരാമീറ്റർ.

ഈ ഫംഗ്‌ഷനുകൾ രീതിയുടെ പേരിന്റെ പ്രിഫിക്‌സായി "സൂപ്പർ" ടോക്കൺ നൽകുന്നു. എങ്കിൽ ശ്രദ്ധിക്കുക
മടങ്ങിയ ഗ്ലോബ് ദീർഘകാലത്തേക്ക് സൂക്ഷിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു, അത് ഉണ്ടോയെന്ന് നിങ്ങൾ പരിശോധിക്കേണ്ടതുണ്ട്
"AUTOLOAD", കാരണം പിന്നീടുള്ള സമയത്ത് കോളിന് മറ്റൊരു സബ്റൂട്ടീൻ ലോഡായേക്കാം
$AUTOLOAD-ലേക്ക് അതിന്റെ മൂല്യം മാറ്റുന്നു. ചെയ്യാൻ ഒരു പാർശ്വഫലമായി സൃഷ്ടിച്ച ഗ്ലോബ് ഉപയോഗിക്കുക
ഈ.

ഈ ഫംഗ്‌ഷനുകൾക്ക് "gv_fetchmeth" പോലെ "level==0" ഉള്ള അതേ പാർശ്വഫലങ്ങൾ ഉണ്ട്. ദി
"gv_fetchmeth" നൽകുന്ന GV "call_sv" ലേക്ക് കൈമാറുന്നതിനെതിരെയുള്ള മുന്നറിയിപ്പ് ബാധകമാണ്
ഈ പ്രവർത്തനങ്ങൾക്ക് തുല്യമായി.

GV* gv_fetchmethod_autoload(HV* stash,
കോൺസ്റ്റ് ചാർ* പേര്,
I32 ഓട്ടോലോഡ്)

gv_fetchmeth_autoload
ഇത് "gv_fetchmeth_pvn_autoload" ന്റെ പഴയ രൂപമാണ്, ഇതിന് ഫ്ലാഗ് പാരാമീറ്ററില്ല.

GV* gv_fetchmeth_autoload(HV* stash,
കോൺസ്റ്റ് ചാർ* പേര്,
STRLEN ലെൻ, I32 ലെവൽ)

gv_fetchmeth_pv
കൃത്യം "gv_fetchmeth_pvn" പോലെയാണ്, എന്നാൽ a ന് പകരം ഒരു nul-terminated string എടുക്കുന്നു
സ്ട്രിംഗ്/നീളം ജോടി.

GV* gv_fetchmeth_pv(HV* സ്റ്റാഷ്, കോൺസ്റ്റ് ചാർ* പേര്,
I32 ലെവൽ, U32 ഫ്ലാഗുകൾ)

gv_fetchmeth_pvn
നൽകിയിരിക്കുന്ന "പേരും" നിർവ്വചിച്ച സബ്റൂട്ടീനും അല്ലെങ്കിൽ "NULL" ഉപയോഗിച്ച് ഗ്ലോബ് നൽകുന്നു. ദി
തന്നിരിക്കുന്ന "സ്റ്റാഷിൽ" അല്ലെങ്കിൽ @ISA വഴി ആക്‌സസ് ചെയ്യാവുന്ന സ്റ്റാഷുകളിലോ ഗ്ലോബ് താമസിക്കുന്നു
യൂണിവേഴ്സൽ::.

ആർഗ്യുമെന്റ് "ലെവൽ" ഒന്നുകിൽ 0 അല്ലെങ്കിൽ -1 ആയിരിക്കണം. "ലെവൽ==0" ആണെങ്കിൽ, ഒരു പാർശ്വഫലമായി
നൽകിയിരിക്കുന്ന "സ്റ്റാഷിൽ" നൽകിയിരിക്കുന്ന "പേര്" ഉപയോഗിച്ച് ഒരു ഗ്ലോബ് സൃഷ്ടിക്കുന്നു
success എന്നതിൽ സബ്റൂട്ടീനിന് ഒരു അപരനാമം അടങ്ങിയിരിക്കുന്നു, ഇതിനായി കാഷിംഗ് വിവരങ്ങൾ സജ്ജീകരിക്കുന്നു
ഗ്ലോബ്.

"ഫ്ലാഗുകൾ" എന്നതിനുള്ള പ്രധാന മൂല്യങ്ങൾ GV_SUPER, SVf_UTF8 എന്നിവയാണ്.

GV_SUPER സൂചിപ്പിക്കുന്നത്, ഈ രീതിയുടെ സൂപ്പർക്ലാസ്സുകളിൽ ഞങ്ങൾ നോക്കാൻ ആഗ്രഹിക്കുന്നു എന്നാണ്
"സ്റ്റാഷ്".

"gv_fetchmeth"-ൽ നിന്ന് ലഭിച്ച GV ഒരു മെത്തേഡ് കാഷെ എൻട്രി ആയിരിക്കാം, അത് അങ്ങനെയല്ല
പേൾ കോഡിന് ദൃശ്യമാണ്. അതിനാൽ "call_sv" എന്ന് വിളിക്കുമ്പോൾ, നിങ്ങൾ GV ഉപയോഗിക്കരുത്
നേരിട്ട്; പകരം, നിങ്ങൾ രീതിയുടെ CV ഉപയോഗിക്കണം, അത് ഇതിൽ നിന്ന് ലഭിക്കും
"GvCV" മാക്രോ ഉള്ള ജി.വി.

GV* gv_fetchmeth_pvn(HV* സ്റ്റാഷ്, കോൺസ്റ്റ് ചാർ* പേര്,
STRLEN ലെൻ, I32 ലെവൽ,
U32 പതാകകൾ)

gv_fetchmeth_pvn_autoload
അതുപോലെ തന്നെ gv_fetchmeth_pvn(), എന്നാൽ ഓട്ടോലോഡ് ചെയ്ത സബ്റൂട്ടിനുകൾക്കും വേണ്ടി നോക്കുന്നു. റിട്ടേണുകൾ എ
സബ്റൂട്ടീനിനുള്ള ഗ്ലോബ്.

ഒരു ജിവി ഇല്ലാതെ ഒരു ഓട്ടോലോഡ് ചെയ്ത സബ്റൂട്ടീന്, "ലെവൽ < 0" ആണെങ്കിലും ഒരു ജിവി സൃഷ്ടിക്കും.
അപൂർണ്ണമായ ഒരു ഓട്ടോലോഡ് ചെയ്ത സബ്റൂട്ടീന്, GvCV() ഫലത്തിന്റെ പൂജ്യം ആയിരിക്കാം.

നിലവിൽ, "ഫ്ലാഗുകൾ" എന്നതിനുള്ള ഒരേയൊരു പ്രധാന മൂല്യം SVf_UTF8 ആണ്.

GV* gv_fetchmeth_pvn_autoload(HV* സ്റ്റാഷ്,
കോൺസ്റ്റ് ചാർ* പേര്,
STRLEN ലെൻ, I32 ലെവൽ,
U32 പതാകകൾ)

gv_fetchmeth_pv_autoload
കൃത്യമായി "gv_fetchmeth_pvn_autoload" പോലെ, എന്നാൽ ഒരു അസാധുവായ സ്ട്രിംഗ് എടുക്കുന്നു
ഒരു സ്ട്രിംഗ്/നീളമുള്ള ജോഡിക്ക് പകരം.

GV* gv_fetchmeth_pv_autoload(HV* സ്റ്റാഷ്,
കോൺസ്റ്റ് ചാർ* പേര്,
I32 ലെവൽ, U32 ഫ്ലാഗുകൾ)

gv_fetchmeth_sv
കൃത്യമായി "gv_fetchmeth_pvn" പോലെ, എന്നാൽ ഒരു SV രൂപത്തിൽ പേര് സ്ട്രിംഗ് എടുക്കുന്നു
ഒരു സ്ട്രിംഗ്/നീളമുള്ള ജോഡിക്ക് പകരം.

GV* gv_fetchmeth_sv(HV* stash, SV* namesv,
I32 ലെവൽ, U32 ഫ്ലാഗുകൾ)

gv_fetchmeth_sv_autoload
കൃത്യമായി "gv_fetchmeth_pvn_autoload" പോലെയാണ്, എന്നാൽ പേര് സ്ട്രിംഗിന്റെ രൂപത്തിൽ എടുക്കുന്നു
ഒരു സ്ട്രിംഗ്/നീളമുള്ള ജോഡിക്ക് പകരം ഒരു SV.

GV* gv_fetchmeth_sv_autoload(HV* stash, SV* namesv,
I32 ലെവൽ, U32 ഫ്ലാഗുകൾ)

gv_init എന്നതിന്റെ പഴയ രൂപം gv_init_pvn(). UTF8 സ്ട്രിംഗുകൾ ഇല്ലാത്തതിനാൽ ഇത് പ്രവർത്തിക്കില്ല
ഫ്ലാഗ് പാരാമീറ്റർ. "multi" പരാമീറ്റർ സജ്ജമാക്കിയാൽ, GV_ADDMULTI ഫ്ലാഗ് ആയിരിക്കും
ലേക്ക് കൈമാറി gv_init_pvn().

void gv_init(GV* gv, HV* സ്റ്റാഷ്, കോൺസ്റ്റ് ചാർ* പേര്,
STRLEN ലെൻ, int മൾട്ടി)

gv_init_pv
അതുപോലെ തന്നെ gv_init_pvn(), എന്നാൽ പേരിന് പകരം ഒരു അസാധുവായ സ്ട്രിംഗ് എടുക്കുന്നു
പ്രത്യേക char *, നീളം പരാമീറ്ററുകൾ.

void gv_init_pv(GV* gv, HV* സ്റ്റാഷ്, കോൺസ്റ്റ് ചാർ* പേര്,
U32 പതാകകൾ)

gv_init_pvn
ഒരു സ്കെയിലറിനെ ടൈപ്പ്ഗ്ലോബാക്കി മാറ്റുന്നു. ഇതൊരു അപ്രസക്തമായ ടൈപ്പ്ഗ്ലോബാണ്; എ നിയോഗിക്കുന്നു
അതിനെ കുറിച്ചുള്ള റഫറൻസ് അതിന്റെ സ്ലോട്ടുകളിൽ ഒന്നിലേക്ക് അസൈൻ ചെയ്യും, പകരം അതിനെ ഇങ്ങനെ തിരുത്തിയെഴുതും
SvSetSV സൃഷ്ടിച്ച ടൈപ്പ്ഗ്ലോബുകളിൽ സംഭവിക്കുന്നു. ഏത് സ്കെയിലറും പരിവർത്തനം ചെയ്യുന്നു SvOK()
പ്രവചനാതീതമായ ഫലങ്ങൾ ഉണ്ടാക്കിയേക്കാം, ഇത് perl-ന്റെ ആന്തരിക ഉപയോഗത്തിനായി നീക്കിവച്ചിരിക്കുന്നു.

"gv" എന്നത് പരിവർത്തനം ചെയ്യേണ്ട സ്കെയിലർ ആണ്.

എന്തെങ്കിലും ഉണ്ടെങ്കിൽ "stash" എന്നത് പാരന്റ് സ്റ്റാഷ്/പാക്കേജ് ആണ്.

"പേര്", "ലെൻ" എന്നിവ പേര് നൽകുന്നു. പേര് യോഗ്യതയില്ലാത്തതായിരിക്കണം; അതായത്, അത് വേണം
പാക്കേജിന്റെ പേര് ഉൾപ്പെടുത്തരുത്. "gv" ഒരു സ്റ്റാഷ് മൂലകമാണെങ്കിൽ, അത് വിളിക്കുന്നയാളുടേതാണ്
ഈ ഫംഗ്‌ഷനിലേക്ക് നൽകിയ പേര് അതിന്റെ പേരുമായി പൊരുത്തപ്പെടുന്നുണ്ടെന്ന് ഉറപ്പാക്കാനുള്ള ഉത്തരവാദിത്തം
ഘടകം. ഇത് പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, perl-ന്റെ ആന്തരിക ബുക്ക് കീപ്പിംഗ് ഇല്ലാതാകും
സമന്വയം.

"പേര്" ഒരു UTF8 സ്ട്രിംഗ് ആണെങ്കിൽ, അല്ലെങ്കിൽ റിട്ടേൺ മൂല്യം ആണെങ്കിൽ "ഫ്ലാഗുകൾ" SVf_UTF8 ആയി സജ്ജീകരിക്കാം
SvUTF8(sv). ഇതിന് GV_ADDMULTI ഫ്ലാഗ് എടുക്കാം, അതായത് അത് നടിക്കുക
GV മുമ്പ് കണ്ടിട്ടുണ്ട് (അതായത്, "ഒരിക്കൽ ഉപയോഗിച്ച" മുന്നറിയിപ്പുകൾ അടിച്ചമർത്തുക).

void gv_init_pvn(GV* gv, HV* സ്റ്റാഷ്, കോൺസ്റ്റ് ചാർ* പേര്,
STRLEN ലെൻ, U32 പതാകകൾ)

gv_init_sv
അതുപോലെ തന്നെ gv_init_pvn(), എന്നാൽ പ്രത്യേക പ്രതീകത്തിന് പകരം ഒരു SV * എടുക്കുന്നു
നീളം പരാമീറ്ററുകളും. "കൊടികൾ" നിലവിൽ ഉപയോഗിക്കാത്തതാണ്.

void gv_init_sv(GV* gv, HV* stash, SV* namesv,
U32 പതാകകൾ)

gv_stashpv
ഒരു നിർദ്ദിഷ്ട പാക്കേജിനായി സ്റ്റാഷിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു. ഇതിനായി "strlen" ഉപയോഗിക്കുന്നു
"പേരിന്റെ" ദൈർഘ്യം നിർണ്ണയിക്കുക, തുടർന്ന് "gv_stashpvn()" എന്ന് വിളിക്കുന്നു.

HV* gv_stashpv(const char* name, I32 ഫ്ലാഗുകൾ)

gv_stashpvn
ഒരു നിർദ്ദിഷ്ട പാക്കേജിനായി സ്റ്റാഷിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു. "namelen" പാരാമീറ്റർ
ബൈറ്റുകളിൽ "പേരിന്റെ" ദൈർഘ്യം സൂചിപ്പിക്കുന്നു. "പതാകകൾ" കൈമാറുന്നു
"gv_fetchpvn_flags()", അതിനാൽ "GV_ADD" ആയി സജ്ജീകരിച്ചാൽ പാക്കേജ് സൃഷ്ടിക്കപ്പെടും
അത് ഇതിനകം നിലവിലില്ല. പാക്കേജ് നിലവിലില്ലെങ്കിൽ "ഫ്ലാഗുകൾ" 0 ആണെങ്കിൽ (അല്ലെങ്കിൽ ഏതെങ്കിലും
പാക്കേജുകൾ സൃഷ്ടിക്കാത്ത മറ്റ് ക്രമീകരണം) അപ്പോൾ NULL തിരികെ നൽകും.

പതാകകൾ ഇവയിലൊന്നായിരിക്കാം:

GV_ADD
SVf_UTF8
GV_NOADD_NOINIT
GV_NOINIT
GV_NOEXPAND
GV_ADDMG

അവയിൽ ഏറ്റവും പ്രധാനപ്പെട്ടത് ഒരുപക്ഷേ GV_ADD, SVf_UTF8 എന്നിവയാണ്.

ശ്രദ്ധിക്കുക, സാധ്യമായ ഇടങ്ങളിൽ "gv_stashpvn" എന്നതിന് പകരം "gv_stashsv" ഉപയോഗിക്കുക
പ്രകടന കാരണങ്ങളാൽ ശുപാർശ ചെയ്യുന്നു.

HV* gv_stashpvn(const char* name, U32 namelen,
I32 പതാകകൾ)

gv_stashpvs
"gv_stashpvn" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/നീളമുള്ള ജോഡിക്ക് പകരം ഒരു ലിറ്ററൽ സ്ട്രിംഗ് എടുക്കുന്നു.

HV* gv_stashpvs(const char* name, I32 create)

gv_stashsv
ഒരു നിർദ്ദിഷ്ട പാക്കേജിനായി സ്റ്റാഷിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു. "gv_stashpvn" കാണുക.

ഈ ഇന്റർഫേസ് പ്രകടനത്തിന് "gv_stashpvn" എന്നതിനേക്കാൾ ശക്തമായി തിരഞ്ഞെടുക്കപ്പെട്ടതാണെന്ന് ശ്രദ്ധിക്കുക
കാരണങ്ങൾ.

HV* gv_stashsv(SV* sv, I32 ഫ്ലാഗുകൾ)

പിരിഞ്ഞു
ഔട്ട്‌പുട്ടിനുള്ള ഡിഫോൾട്ട് ഫയൽ ഹാൻഡിലായ PL_defoutgv, പാസാക്കിയ ടൈപ്പ്ഗ്ലോബിലേക്ക് സജ്ജമാക്കുന്നു.
PL_defoutgv അതിന്റെ ടൈപ്പ്ഗ്ലോബിൽ ഒരു റഫറൻസ് "സ്വന്തമാക്കുന്നു" എന്നതിനാൽ, ഇതിന്റെ റഫറൻസ് എണ്ണം
ടൈപ്പ്ഗ്ലോബിൽ പാസായത് ഒന്നായി വർദ്ധിച്ചു, ടൈപ്പ്ഗ്ലോബിന്റെ റഫറൻസ് എണ്ണം
PL_defoutgv പോയിന്റുകൾ ഒന്നായി കുറഞ്ഞു.

ശൂന്യമായ സെറ്റ് ഡിഫൗട്ട് (GV* gv)

മൊബൈൽ മൂല്യങ്ങൾ

Nullav Null AV പോയിന്റർ.

(ഒഴിവാക്കി - പകരം "(AV *)NULL" ഉപയോഗിക്കുക)

Nullch Null പ്രതീക പോയിന്റർ. ("PERL_CORE" നിർവചിക്കുമ്പോൾ ഇനി ലഭ്യമല്ല.)

Nullcv Null CV പോയിന്റർ.

(ഒഴിവാക്കി - പകരം "(CV *)NULL" ഉപയോഗിക്കുക)

Nullhv Null HV പോയിന്റർ.

(ഒഴിവാക്കി - പകരം "(HV *)NULL" ഉപയോഗിക്കുക)

Nullsv Null SV പോയിന്റർ. ("PERL_CORE" നിർവചിക്കുമ്പോൾ ഇനി ലഭ്യമല്ല.)

ഹാഷ് കൃത്രിമം പ്രവർത്തനങ്ങൾ

ഒരു HV ഘടന ഒരു പേൾ ഹാഷിനെ പ്രതിനിധീകരിക്കുന്നു. ഇതിൽ പ്രധാനമായും ഓരോ പോയിന്ററുകളും അടങ്ങിയിരിക്കുന്നു
ഇതിൽ HE ഘടനകളുടെ ഒരു ലിങ്ക്ഡ് ലിസ്റ്റിലേക്ക് വിരൽ ചൂണ്ടുന്നു. ഹാഷ് ഉപയോഗിച്ച് അറേ സൂചികയിലാക്കിയിരിക്കുന്നു
കീയുടെ പ്രവർത്തനം, അതിനാൽ ഓരോ ലിങ്ക് ചെയ്ത ലിസ്റ്റും എല്ലാ ഹാഷ് എൻട്രികളെയും ഒരേ പോലെ പ്രതിനിധീകരിക്കുന്നു
ഹാഷ് മൂല്യം. ഓരോ HEയിലും യഥാർത്ഥ മൂല്യത്തിലേക്കുള്ള ഒരു പോയിന്ററും ഒരു HEK-ലേക്കുള്ള ഒരു പോയിന്ററും അടങ്ങിയിരിക്കുന്നു
കീയും ഹാഷ് മൂല്യവും കൈവശമുള്ള ഘടന.

cop_fetch_label
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു പോലീസുകാരനിൽ ഘടിപ്പിച്ചിരിക്കുന്ന ലേബൽ തിരികെ നൽകുന്നു. ഫ്ലാഗ് പോയിന്റർ "SVf_UTF8" ആയി സജ്ജീകരിച്ചേക്കാം
അല്ലെങ്കിൽ 0.

const char * cop_fetch_label(COP *const cop,
STRLEN *len, U32 *പതാകകൾ)

കോപ്പ്_സ്റ്റോർ_ലേബൽ
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു "cop_hints_hash" എന്നതിലേക്ക് ഒരു ലേബൽ സംരക്ഷിക്കുക. നിങ്ങൾ ഒരു ഫ്ലാഗുകൾ "SVf_UTF8" ആയി സജ്ജീകരിക്കേണ്ടതുണ്ട്
utf-8 ലേബൽ.

void cop_store_label(COP *const cop,
കോൺസ്റ്റ് ചാർ *ലേബൽ, STRLEN ലെൻ,
U32 പതാകകൾ)

get_hv വ്യക്തമാക്കിയ Perl ഹാഷിന്റെ HV നൽകുന്നു. "ഫ്ലാഗുകൾ" "gv_fetchpv" ലേക്ക് കൈമാറുന്നു.
"GV_ADD" സജ്ജമാക്കുകയും Perl വേരിയബിൾ നിലവിലില്ലെങ്കിൽ അത് സൃഷ്ടിക്കപ്പെടുകയും ചെയ്യും.
"ഫ്ലാഗുകൾ" പൂജ്യമാണെങ്കിൽ വേരിയബിൾ നിലവിലില്ലെങ്കിൽ NULL തിരികെ നൽകും.

ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷന്റെ perl_ ഫോം ഒഴിവാക്കിയിരിക്കുന്നു.

HV* get_hv(const char *name, I32 ഫ്ലാഗുകൾ)

HEf_SVKEY
ഹാഷ് എൻട്രികളുടെയും മാജിക് ഘടനകളുടെയും നീളം സ്ലോട്ടിൽ ഉപയോഗിച്ചിരിക്കുന്ന ഈ ഫ്ലാഗ് വ്യക്തമാക്കുന്നു
ഘടനയിൽ ഒരു "SV*" പോയിന്റർ അടങ്ങിയിരിക്കുന്നു, അവിടെ ഒരു "char*" പോയിന്റർ പ്രതീക്ഷിക്കാം.
(വിവരങ്ങൾക്ക് മാത്രം--ഉപയോഗിക്കാൻ പാടില്ല).

HeHASH ഹാഷ് എൻട്രിയിൽ സംഭരിച്ചിരിക്കുന്ന കമ്പ്യൂട്ട് ചെയ്ത ഹാഷ് നൽകുന്നു.

U32 ഹെഹാഷ്(അവൻ* അവൻ)

HeKEY ഹാഷ് എൻട്രിയുടെ കീ സ്ലോട്ടിൽ സംഭരിച്ചിരിക്കുന്ന യഥാർത്ഥ പോയിന്റർ നൽകുന്നു. സൂചിക
"HeKLEN()" ന്റെ മൂല്യം അനുസരിച്ച് "char*" അല്ലെങ്കിൽ "SV*" ആകാം. ആകാം
നിയോഗിച്ചിട്ടുള്ള. "HePV()" അല്ലെങ്കിൽ "HeSVKEY()" മാക്രോകൾ സാധാരണയായി ഇതിനായി അഭികാമ്യമാണ്
ഒരു കീയുടെ മൂല്യം കണ്ടെത്തുന്നു.

അസാധുവായ* ഹേക്കി(അവൻ* അവൻ)

HeKLEN ഇത് നെഗറ്റീവ് ആണെങ്കിൽ, അത് "HEf_SVKEY" ആണെങ്കിൽ, അത് എൻട്രി ഹോൾഡ് സൂചിപ്പിക്കുന്നു
"SV*" കീ. അല്ലെങ്കിൽ, കീയുടെ യഥാർത്ഥ ദൈർഘ്യം പിടിക്കുന്നു. ലേക്ക് നിയോഗിക്കാവുന്നതാണ്.
കീ ദൈർഘ്യം കണ്ടെത്തുന്നതിന് "HePV()" മാക്രോ സാധാരണയായി അഭികാമ്യമാണ്.

സ്ട്രെൻ ഹെക്ലെൻ(അവൻ* അവൻ)

HePV ഹാഷ് എൻട്രിയുടെ കീ സ്ലോട്ട് ഒരു "char*" മൂല്യമായി നൽകുന്നു, ആവശ്യമായ എന്തെങ്കിലും ചെയ്തുകൊണ്ട്
സാധ്യതയുള്ള "SV*" കീകൾ ഒഴിവാക്കുന്നു. സ്ട്രിംഗിന്റെ നീളം "ലെൻ" ൽ സ്ഥാപിച്ചിരിക്കുന്നു
(ഇതൊരു മാക്രോ ആണ്, അങ്ങനെ ചെയ്യുക അല്ല &len) ഉപയോഗിക്കുക. നീളം എന്താണെന്ന് നിങ്ങൾ ശ്രദ്ധിക്കുന്നില്ലെങ്കിൽ
പ്രധാന കാര്യം, "PL_na" എന്ന ആഗോള വേരിയബിൾ നിങ്ങൾക്ക് ഉപയോഗിക്കാം, ഇത് വളരെ കുറവാണെങ്കിലും
ഒരു ലോക്കൽ വേരിയബിൾ ഉപയോഗിക്കുന്നതിനേക്കാൾ കാര്യക്ഷമമാണ്. എന്നിരുന്നാലും, perl-ലെ ഹാഷ് കീകൾ ഓർക്കുക
ഉൾച്ചേർത്ത നല്ലുകൾ ഉൾക്കൊള്ളാൻ സ്വാതന്ത്ര്യമുണ്ട്, അതിനാൽ "strlen()" അല്ലെങ്കിൽ സമാനമായത് ഉപയോഗിക്കുന്നത് നല്ലതല്ല
ഹാഷ് കീകളുടെ ദൈർഘ്യം കണ്ടെത്താനുള്ള വഴി. ഇത് "SvPV()" മാക്രോയുമായി വളരെ സാമ്യമുള്ളതാണ്
ഈ പ്രമാണത്തിൽ മറ്റൊരിടത്ത് വിവരിച്ചിരിക്കുന്നു. "HeUTF8" എന്നതും കാണുക.

ഒരു പുതിയ എസ്‌വി സൃഷ്‌ടിക്കാൻ "newSVpvn()" എന്നതിലേക്ക് മൂല്യങ്ങൾ ലഭിക്കുന്നതിന് നിങ്ങൾ "HePV" ഉപയോഗിക്കുകയാണെങ്കിൽ,
കൂടുതൽ കാര്യക്ഷമമായതിനാൽ "newSVhek(HeKEY_hek(he))" ഉപയോഗിക്കുന്നത് നിങ്ങൾ പരിഗണിക്കണം.

char* HePV(HE* he, STRLEN ലെൻ)

ഹാഷ് എൻട്രിയിൽ ഒരു "SV*" ഇല്ലെങ്കിൽ HeSVKEY കീ ഒരു "SV*" അല്ലെങ്കിൽ "NULL" ആയി നൽകുന്നു.
കീ.

SV* HeSVKEY(അവൻ* അവൻ)

HeSVKEY_force
കീ ഒരു "SV*" ആയി നൽകുന്നു. എങ്കിൽ ഒരു താൽക്കാലിക മാരകമായ "SV*" സൃഷ്‌ടിക്കുകയും തിരികെ നൽകുകയും ചെയ്യും
ഹാഷ് എൻട്രിയിൽ ഒരു "char*" കീ മാത്രമേ അടങ്ങിയിട്ടുള്ളൂ.

SV* HeSVKEY_force(HE* he)

HeSVKEY_സെറ്റ്
നൽകിയിരിക്കുന്ന "SV*"-ലേക്ക് കീ സജ്ജീകരിക്കുന്നു, ഉചിതമായ ഫ്ലാഗുകൾ സജ്ജീകരിക്കാൻ ശ്രദ്ധിക്കുക
ഒരു "SV*" കീയുടെ സാന്നിധ്യം സൂചിപ്പിക്കുകയും അതേ "SV*" നൽകുകയും ചെയ്യുന്നു.

SV* HeSVKEY_set(HE* he, SV* sv)

"HePV" നൽകുന്ന "char *" മൂല്യം UTF-8-ൽ എൻകോഡ് ചെയ്‌തിട്ടുണ്ടോ എന്ന് HeUTF8 നൽകുന്നു.
സാധ്യമായ "SV*" കീകളുടെ ഏതെങ്കിലും ആവശ്യമായ ഡീറഫറൻസിംഗ്. തിരികെ നൽകിയ മൂല്യം 0 ആയിരിക്കും
അല്ലെങ്കിൽ നോൺ-0, നിർബന്ധമായും 1 അല്ല (അല്ലെങ്കിൽ ഏതെങ്കിലും കുറഞ്ഞ ബിറ്റുകൾ സജ്ജീകരിച്ച ഒരു മൂല്യം പോലും), അങ്ങനെ do അല്ല
"bool" എന്നത് "char" എന്നതിന്റെ ടൈപ്പ്‌ഡെഫ് ആയതിനാൽ ഇത് ഒരു "bool" വേരിയബിളിലേക്ക് അന്ധമായി നിയോഗിക്കുക.

U32 HeUTF8(HE* he)

HeVAL ഹാഷ് എൻട്രിയിൽ സംഭരിച്ചിരിക്കുന്ന മൂല്യ സ്ലോട്ട് (തരം "SV*") നൽകുന്നു. ലേക്ക് നിയോഗിക്കാം.

SV *foo= HeVAL(hv);
HeVAL(hv)= sv;

എസ്വി* ഹേവൽ(അവൻ* അവൻ)

HvENAME ഒരു സ്റ്റാഷിന്റെ ഫലപ്രദമായ പേര് നൽകുന്നു, അല്ലെങ്കിൽ ഒന്നുമില്ലെങ്കിൽ NULL. ഫലപ്രദമായ
ഈ സ്റ്റാഷ് താമസിക്കുന്ന ചിഹ്ന പട്ടികയിലെ ഒരു സ്ഥലത്തെ പേര് പ്രതിനിധീകരിക്കുന്നു. അത്
പാക്കേജുകൾ അപരനാക്കുകയോ ഇല്ലാതാക്കുകയോ ചെയ്യുമ്പോൾ യാന്ത്രികമായി അപ്ഡേറ്റ് ചെയ്യുന്നു. ഇല്ല എന്ന ഒരു ശേഖരം
ചിഹ്ന പട്ടികയിൽ ഇനി ഫലപ്രദമായ പേരില്ല. ഈ പേരാണ് അഭികാമ്യം
MRO ലീനിയറൈസേഷനുകളിലും isa കാഷെകളിലും ഉപയോഗിക്കുന്നതിന് "HvNAME".

char* HvENAME(HV* സ്റ്റാഷ്)

HvENAMELEN
സ്റ്റാഷിന്റെ ഫലവത്തായ പേരിന്റെ ദൈർഘ്യം നൽകുന്നു.

STRLEN HvENAMELEN(HV *stash)

HvENAMEUTF8
ഫലപ്രദമായ പേര് UTF8 എൻകോഡിംഗിലാണെങ്കിൽ ശരി എന്ന് നൽകുന്നു.

ഒപ്പിടാത്ത ചാർ HvENAMEUTF8(HV *stash)

HvNAME ഒരു സ്റ്റാഷിന്റെ പാക്കേജിന്റെ പേര് നൽകുന്നു, അല്ലെങ്കിൽ "stash" ഒരു സ്റ്റാഷ് അല്ലെങ്കിൽ NULL. കാണുക
"SvSTASH", "CvSTASH".

char* HvNAME(HV* സ്റ്റാഷ്)

HvNAMELEN
സ്റ്റാഷിന്റെ പേരിന്റെ ദൈർഘ്യം നൽകുന്നു.

STRLEN HvNAMELEN(HV *stash)

HvNAMEUTF8
പേര് UTF8 എൻകോഡിംഗിലാണെങ്കിൽ ശരി എന്ന് നൽകുന്നു.

ഒപ്പിടാത്ത ചാർ HvNAMEUTF8(HV *stash)

hv_assert
ഒരു ഹാഷ് ആന്തരികമായി സ്ഥിരതയുള്ള അവസ്ഥയിലാണോയെന്ന് പരിശോധിക്കുക.

void hv_assert(HV *hv)

hv_clear
ഒരു ഹാഷിന്റെ എല്ലാ ഘടകങ്ങളെയും സ്വതന്ത്രമാക്കുന്നു, അത് ശൂന്യമാക്കുന്നു. XS എന്നതിന് തുല്യമാണ്
"%hash = ()". "hv_undef" എന്നതും കാണുക.

തിരിച്ചുവരുമ്പോൾ ഹാഷ് അസാധുവാകാനുള്ള സാധ്യതയെക്കുറിച്ചുള്ള കുറിപ്പിനായി "av_clear" കാണുക.

void hv_clear(HV *hv)

hv_clear_placeholders
ഒരു ഹാഷിൽ നിന്ന് ഏതെങ്കിലും പ്ലെയ്‌സ്‌ഹോൾഡറുകൾ മായ്‌ക്കുന്നു. നിയന്ത്രിത ഹാഷിന് അതിന്റെ ഏതെങ്കിലും കീകൾ ഉണ്ടെങ്കിൽ
വായിക്കാൻ മാത്രമായി അടയാളപ്പെടുത്തുകയും കീ പിന്നീട് ഇല്ലാതാക്കപ്പെടുകയും ചെയ്യുന്നു, കീ യഥാർത്ഥത്തിൽ അല്ല
ഇല്ലാതാക്കി എന്നാൽ &PL_sv_placeholder എന്നതിന്റെ മൂല്യം നൽകി അടയാളപ്പെടുത്തിയിരിക്കുന്നു. ഇത് ടാഗ് ചെയ്യുന്നു
അതിനാൽ ഹാഷിലൂടെ ആവർത്തിക്കുന്നത് പോലുള്ള ഭാവി പ്രവർത്തനങ്ങൾ ഇത് അവഗണിക്കപ്പെടും, പക്ഷേ
ഭാവിയിൽ കീയിലേക്ക് ഒരു മൂല്യം വീണ്ടും അസൈൻ ചെയ്യാൻ ഹാഷിനെ അനുവദിക്കും
പോയിന്റ്. ഈ ഫംഗ്‌ഷൻ അത്തരം പ്ലെയ്‌സ്‌ഹോൾഡർ കീകൾ ഹാഷിൽ നിന്ന് മായ്‌ക്കുന്നു. കാണുക
ഹാഷ്::Util::lock_keys() അതിന്റെ ഉപയോഗത്തിന്റെ ഒരു ഉദാഹരണത്തിനായി.

void hv_clear_placeholders(HV *hv)

hv_copy_hints_hv
"%^H" പകർത്തുന്നതിനായി "newHVhv" യുടെ ഒരു പ്രത്യേക പതിപ്പ്. ohv a എന്നതിലേക്കുള്ള ഒരു സൂചനയായിരിക്കണം
ഹാഷ് ("%^H" മാജിക് ഉണ്ടായിരിക്കാം, പക്ഷേ പൊതുവെ മാന്ത്രികമല്ലാത്തതായിരിക്കണം), അല്ലെങ്കിൽ "NULL"
(ശൂന്യമായ ഹാഷ് ആയി വ്യാഖ്യാനിക്കുന്നു). എന്നതിന്റെ ഉള്ളടക്കം ohv ഒരു പുതിയ ഹാഷിലേക്ക് പകർത്തി
അതിൽ "%^H"-നിർദ്ദിഷ്ട മാജിക് ചേർത്തിട്ടുണ്ട്. പുതിയ ഹാഷിലേക്കുള്ള ഒരു പോയിന്റർ തിരികെ ലഭിച്ചു.

HV * hv_copy_hints_hv(HV *ohv)

hv_delete
ഹാഷിലെ ഒരു കീ/മൂല്യം ജോടി ഇല്ലാതാക്കുന്നു. മൂല്യത്തിന്റെ SV ഹാഷിൽ നിന്ന് നീക്കംചെയ്‌തു,
മർത്യനാക്കി, വിളിച്ചയാളുടെ അടുത്തേക്ക് മടങ്ങി. "ക്ലെൻ" എന്നതിന്റെ സമ്പൂർണ്ണ മൂല്യം
കീയുടെ നീളം. "klen" നെഗറ്റീവ് ആണെങ്കിൽ കീ ഇൻ ആണെന്ന് അനുമാനിക്കപ്പെടുന്നു
UTF-8-എൻകോഡ് ചെയ്ത യൂണികോഡ്. "ഫ്ലാഗുകൾ" മൂല്യം സാധാരണയായി പൂജ്യമായിരിക്കും; സജ്ജമാക്കിയാൽ
G_DISCARD തുടർന്ന് NULL തിരികെ നൽകും. കീ ആണെങ്കിൽ NULL തിരികെ നൽകും
കണ്ടെത്തിയില്ല.

SV* hv_delete(HV *hv, കോൺസ്റ്റ് ചാർ *കീ, I32 klen,
I32 പതാകകൾ)

hv_delete_ent
ഹാഷിലെ ഒരു കീ/മൂല്യം ജോടി ഇല്ലാതാക്കുന്നു. ഉണ്ടാക്കിയ ഹാഷിൽ നിന്ന് മൂല്യം SV നീക്കം ചെയ്തു
മർത്യൻ, വിളിച്ചയാളുടെ അടുത്തേക്ക് മടങ്ങി. "ഫ്ലാഗുകൾ" മൂല്യം സാധാരണയായി പൂജ്യമായിരിക്കും; എങ്കിൽ
G_DISCARD ആയി സജ്ജീകരിച്ച ശേഷം NULL തിരികെ നൽകും. ആണെങ്കിൽ NULL തിരികെ നൽകും
താക്കോൽ കണ്ടെത്തിയില്ല. "hash" എന്നത് ഒരു സാധുവായ പ്രീകംപ്യൂട്ടഡ് ഹാഷ് മൂല്യം ആകാം, അല്ലെങ്കിൽ ചോദിക്കാൻ 0 ആകാം
അത് കണക്കാക്കണം.

SV* hv_delete_ent(HV *hv, SV *keysv, I32 ഫ്ലാഗുകൾ,
U32 ഹാഷ്)

hv_ നിലവിലുണ്ട്
നിർദ്ദിഷ്ട ഹാഷ് കീ നിലവിലുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു. കേവല
"klen" ന്റെ മൂല്യം കീയുടെ നീളമാണ്. "klen" നെഗറ്റീവ് ആണെങ്കിൽ കീ ആണ്
യു‌ടി‌എഫ്-8-എൻ‌കോഡുചെയ്‌ത യൂണികോഡിലാണെന്ന് അനുമാനിക്കുന്നു.

bool hv_exist(HV *hv, const char *key, I32 klen)

hv_exists_ent
നിർദ്ദിഷ്ട ഹാഷ് കീ നിലവിലുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു. "ഹാഷ്" ആകാം
ഒരു സാധുവായ പ്രീകംപ്യൂട്ടഡ് ഹാഷ് മൂല്യം, അല്ലെങ്കിൽ അത് കണക്കാക്കാൻ ആവശ്യപ്പെടുന്നതിന് 0.

bool hv_exists_ent(HV *hv, SV *keysv, U32 ഹാഷ്)

hv_fetch
ഹാഷിലെ നിർദ്ദിഷ്ട കീയുമായി പൊരുത്തപ്പെടുന്ന SV നൽകുന്നു. കേവല
"klen" ന്റെ മൂല്യം കീയുടെ നീളമാണ്. "klen" നെഗറ്റീവ് ആണെങ്കിൽ കീ ആണ്
യു‌ടി‌എഫ്-8-എൻ‌കോഡുചെയ്‌ത യൂണികോഡിലാണെന്ന് അനുമാനിക്കുന്നു. "lval" സജ്ജീകരിച്ചാൽ, അത് നേടും
ഒരു കടയുടെ ഭാഗം. ഇതിനർത്ഥം ബന്ധപ്പെട്ട ഹാഷിൽ മൂല്യമില്ലെങ്കിൽ എന്നാണ്
നൽകിയിരിക്കുന്ന കീ, തുടർന്ന് ഒന്ന് സൃഷ്ടിക്കപ്പെടുകയും അതിലേക്കുള്ള ഒരു പോയിന്റർ തിരികെ നൽകുകയും ചെയ്യുന്നു. "SV*" അത്
എന്നതിലേക്ക് പോയിന്റുകൾ നൽകാം. എന്നാൽ റിട്ടേൺ മൂല്യം അസാധുവാണോ എന്ന് എപ്പോഴും പരിശോധിക്കുക
ഒരു "SV*" ലേക്ക് മാറ്റുന്നതിന് മുമ്പ്.

കൂടുതൽ അറിയാൻ പെർൾഗട്ടിലെ "അണ്ടർസ്റ്റാൻഡിംഗ് ദി മാജിക് ഓഫ് ടൈഡ് ഹാഷുകളുടെയും അറേകളുടെയും" കാണുക
ടൈഡ് ഹാഷുകളിൽ ഈ ഫംഗ്‌ഷൻ എങ്ങനെ ഉപയോഗിക്കാം എന്നതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ.

SV** hv_fetch(HV *hv, const char *key, I32 klen,
I32 lval)

hv_fetchs
"hv_fetch" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/നീളമുള്ള ജോഡിക്ക് പകരം ഒരു ലിറ്ററൽ സ്ട്രിംഗ് എടുക്കുന്നു.

SV** hv_fetchs(HV* tb, const char* കീ, I32 lval)

hv_fetch_ent
ഹാഷിലെ നിർദ്ദിഷ്ട കീയുമായി പൊരുത്തപ്പെടുന്ന ഹാഷ് എൻട്രി നൽകുന്നു. "ഹാഷ്"
തന്നിരിക്കുന്ന "കീ"യ്‌ക്കായുള്ള സാധുവായ പ്രീകംപ്യൂട്ടഡ് ഹാഷ് നമ്പർ ആയിരിക്കണം അല്ലെങ്കിൽ നിങ്ങൾക്ക് വേണമെങ്കിൽ 0 ആയിരിക്കണം
അത് കണക്കാക്കുന്നതിനുള്ള പ്രവർത്തനം. "lval" സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, അത് ഒരു സ്റ്റോറിന്റെ ഭാഗമാകും.
റിട്ടേൺ മൂല്യം ആക്‌സസ് ചെയ്യുന്നതിന് മുമ്പ് അത് അസാധുവാണെന്ന് ഉറപ്പാക്കുക. റിട്ടേൺ മൂല്യം എപ്പോൾ
"hv" എന്നത് ഒരു ടൈഡ് ഹാഷ് ഒരു സ്റ്റാറ്റിക് ലൊക്കേഷനിലേക്കുള്ള ഒരു പോയിന്ററാണ്, അതിനാൽ ഒരു പകർപ്പ് ഉണ്ടാക്കുന്നത് ഉറപ്പാക്കുക
നിങ്ങൾക്ക് അത് എവിടെയെങ്കിലും സൂക്ഷിക്കണമെങ്കിൽ ഘടനയുടെ.

കൂടുതൽ അറിയാൻ പെർൾഗട്ടിലെ "അണ്ടർസ്റ്റാൻഡിംഗ് ദി മാജിക് ഓഫ് ടൈഡ് ഹാഷുകളുടെയും അറേകളുടെയും" കാണുക
ടൈഡ് ഹാഷുകളിൽ ഈ ഫംഗ്‌ഷൻ എങ്ങനെ ഉപയോഗിക്കാം എന്നതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ.

HE* hv_fetch_ent(HV *hv, SV *keysv, I32 lval,
U32 ഹാഷ്)

hv_fill ഉപയോഗത്തിലിരിക്കുന്ന ഹാഷ് ബക്കറ്റുകളുടെ എണ്ണം നൽകുന്നു. ഈ പ്രവർത്തനം ആണ്
മാക്രോ "HvFILL" കൊണ്ട് പൊതിഞ്ഞു.

മുമ്പ്, ഈ മൂല്യം എല്ലായ്പ്പോഴും HV ഘടനയിൽ സംഭരിക്കപ്പെട്ടിരുന്നു, അത് സൃഷ്ടിച്ചു
എല്ലാ ഹാഷിലും (കൂടാതെ എല്ലാ ഒബ്‌ജക്‌റ്റിലും) ഓവർഹെഡ് ആയിരുന്നു എന്തെങ്കിലുമൊക്കെ
അപൂർവ്വമായി ഉപയോഗിക്കുന്നു. ഇപ്പോൾ ഞങ്ങൾ അത് ആദ്യമായി ആവശ്യമുള്ളപ്പോൾ ആവശ്യാനുസരണം കണക്കാക്കുന്നു, കൂടാതെ
ആ കണക്കുകൂട്ടൽ ആവർത്തിക്കാൻ ചെലവേറിയതാണെങ്കിൽ അത് കാഷെ ചെയ്യുക. കാഷെ ചെയ്ത മൂല്യം
ഉൾപ്പെടുത്തലുകളും ഇല്ലാതാക്കലും വഴി അപ്‌ഡേറ്റ് ചെയ്‌തു, എന്നാൽ (നിലവിൽ) ഹാഷ് ആണെങ്കിൽ നിരസിച്ചു
രണ്ടായി പിരിയുക.

STRLEN hv_fill(HV *const hv)

hv_iterinit
ഒരു ഹാഷ് പട്ടികയിലൂടെ സഞ്ചരിക്കാൻ ഒരു ആരംഭ പോയിന്റ് തയ്യാറാക്കുന്നു. ഇൻ കീകളുടെ എണ്ണം നൽകുന്നു
ഹാഷ് (അതായത് "HvUSEDKEYS(hv)" പോലെ തന്നെ). റിട്ടേൺ മൂല്യം നിലവിൽ മാത്രമാണ്
ടൈ മാജിക് ഇല്ലാത്ത ഹാഷുകൾക്ക് അർത്ഥം.

ശ്രദ്ധിക്കുക: പതിപ്പ് 5.004_65-ന് മുമ്പ്, "hv_iterinit" ഹാഷിന്റെ എണ്ണം നൽകുന്നതിന് ഉപയോഗിച്ചു
ഉപയോഗത്തിലിരിക്കുന്ന ബക്കറ്റുകൾ. നിങ്ങൾക്ക് ഇപ്പോഴും ആ നിഗൂഢ മൂല്യം ആവശ്യമുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് കഴിയും
മാക്രോ "HvFILL(hv)" വഴി അത് നേടുക.

I32 hv_iterinit(HV *hv)

hv_itekey
ഹാഷ് ഇറ്ററേറ്ററിന്റെ നിലവിലെ സ്ഥാനത്ത് നിന്ന് കീ നൽകുന്നു. കാണുക
"hv_iterinit".

char* hv_iterkey(HE* എൻട്രി, I32* retlen)

hv_iterkeysv
ഹാഷ് ഇറ്ററേറ്ററിന്റെ നിലവിലെ സ്ഥാനത്ത് നിന്ന് കീ "SV*" ആയി നൽകുന്നു. ദി
റിട്ടേൺ മൂല്യം എല്ലായ്പ്പോഴും കീയുടെ ഒരു മോർട്ടൽ കോപ്പി ആയിരിക്കും. കൂടാതെ "hv_iterinit" കാണുക.

SV* hv_iterkeysv(HE* എൻട്രി)

hv_iternext
ഒരു ഹാഷ് ഇറ്ററേറ്ററിൽ നിന്നുള്ള എൻട്രികൾ നൽകുന്നു. "hv_iterinit" കാണുക.

ആവർത്തനത്തിന്റെ ഹാഷ് എൻട്രിയിൽ നിങ്ങൾക്ക് "hv_delete" അല്ലെങ്കിൽ "hv_delete_ent" എന്ന് വിളിക്കാം.
നിങ്ങളുടെ സ്ഥലം നഷ്‌ടപ്പെടാതെയോ നിങ്ങളുടെ ആവർത്തനത്തെ അസാധുവാക്കാതെയോ നിലവിൽ പോയിന്റ് ചെയ്യുന്നു.
ഈ സാഹചര്യത്തിൽ നിങ്ങളുടെ കൂടെയുള്ള ഹാഷിൽ നിന്ന് നിലവിലെ എൻട്രി ഇല്ലാതാക്കി എന്നത് ശ്രദ്ധിക്കുക
അതിനെക്കുറിച്ചുള്ള അവസാന റഫറൻസ് കൈവശമുള്ള ഇറ്ററേറ്റർ. നിങ്ങളുടെ ആവർത്തനത്തെ സ്വതന്ത്രമാക്കാൻ ഫ്ലാഗുചെയ്‌തു
"hv_iternext" എന്നതിലേക്കുള്ള അടുത്ത കോളിൽ പ്രവേശിക്കുക, അതിനാൽ നിങ്ങളുടെ ആവർത്തനത്തെ ഉപേക്ഷിക്കരുത്
ഉടൻ തന്നെ എൻട്രി ചോർന്നുപോകും - ഉറവിടം പ്രവർത്തനക്ഷമമാക്കാൻ "hv_iternext" എന്ന് വിളിക്കുക
ഡീലോക്കേഷൻ.

HE* hv_iternext(HV *hv)

hv_iternextsv
ഒരു ഓപ്പറേഷനിൽ "hv_iternext", "hv_iterkey", "hv_iterval" എന്നിവ നടത്തുന്നു.

SV* hv_iternextsv(HV *hv, char **key, I32 *retlen)

hv_iternext_flags
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു ഹാഷ് ഇറ്ററേറ്ററിൽ നിന്നുള്ള എൻട്രികൾ നൽകുന്നു. "hv_iterinit", "hv_iternext" എന്നിവ കാണുക. ദി
"ഫ്ലാഗുകൾ" മൂല്യം സാധാരണയായി പൂജ്യമായിരിക്കും; HV_ITERNEXT_WANTPLACEHOLDERS സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ
പ്ലെയ്‌സ്‌ഹോൾഡർ കീകൾ (നിയന്ത്രിത ഹാഷുകൾക്ക്) സാധാരണയ്ക്ക് പുറമെ തിരികെ നൽകും
കീകൾ. സ്ഥിരസ്ഥിതിയായി പ്ലെയ്‌സ്‌ഹോൾഡറുകൾ സ്വയമേവ ഒഴിവാക്കപ്പെടും. നിലവിൽ എ
&PL_sv_placeholder എന്ന മൂല്യം ഉപയോഗിച്ചാണ് പ്ലെയ്‌സ്‌ഹോൾഡർ നടപ്പിലാക്കുന്നത്. എന്നത് ശ്രദ്ധിക്കുക
പ്ലെയ്‌സ്‌ഹോൾഡറുകളും നിയന്ത്രിത ഹാഷുകളും നടപ്പിലാക്കുന്നത് മാറിയേക്കാം, കൂടാതെ
ഏത് മാറ്റവും വൃത്തിയുള്ളതായിരിക്കുന്നതിന് നിലവിൽ നടപ്പിലാക്കൽ വേണ്ടത്ര സംഗ്രഹിച്ചിട്ടില്ല.

HE* hv_iternext_flags(HV *hv, I32 ഫ്ലാഗുകൾ)

hv_iterval
ഹാഷ് ഇറ്ററേറ്ററിന്റെ നിലവിലെ സ്ഥാനത്ത് നിന്ന് മൂല്യം നൽകുന്നു. കാണുക
"hv_iterkey".

SV* hv_iterval(HV *hv, HE *entry)

hv_magic
ഒരു ഹാഷിലേക്ക് മാജിക് ചേർക്കുന്നു. "sv_magic" കാണുക.

void hv_magic(HV *hv, GV *gv, int how)

hv_scalar
സ്കെയിലർ സന്ദർഭത്തിൽ ഹാഷിനെ വിലയിരുത്തുകയും ഫലം നൽകുകയും ചെയ്യുന്നു. എപ്പോൾ മാജിക് കൈകാര്യം ചെയ്യുന്നു
ഹാഷ് കെട്ടിയിരിക്കുന്നു.

SV* hv_scalar(HV *hv)

hv_സ്റ്റോർ
ഒരു SV ഒരു ഹാഷിൽ സംഭരിക്കുന്നു. ഹാഷ് കീ "കീ" എന്നും സമ്പൂർണ്ണ മൂല്യമായും വ്യക്തമാക്കിയിരിക്കുന്നു
"klen" എന്നത് കീയുടെ നീളമാണ്. "klen" നെഗറ്റീവ് ആണെങ്കിൽ, കീ അനുമാനിക്കപ്പെടുന്നു
UTF-8-എൻകോഡ് ചെയ്ത യൂണികോഡിൽ ആയിരിക്കുക. "ഹാഷ്" പരാമീറ്റർ മുൻകൂട്ടി തയ്യാറാക്കിയ ഹാഷ് മൂല്യമാണ്;
ഇത് പൂജ്യമാണെങ്കിൽ, Perl അത് കണക്കാക്കും.

പ്രവർത്തനം പരാജയപ്പെട്ടാൽ അല്ലെങ്കിൽ മൂല്യം ആവശ്യമില്ലെങ്കിൽ റിട്ടേൺ മൂല്യം NULL ആയിരിക്കും
യഥാർത്ഥത്തിൽ ഹാഷിനുള്ളിൽ സംഭരിക്കേണ്ടതാണ് (കെട്ടിയ ഹാഷുകളുടെ കാര്യത്തിലെന്നപോലെ). അല്ലെങ്കിൽ
യഥാർത്ഥ "എസ്‌വി*" ലഭിക്കുന്നതിന് ഇത് ഒഴിവാക്കാവുന്നതാണ്. വിളിച്ചയാളാണ് എന്നത് ശ്രദ്ധിക്കുക
മുമ്പുള്ള "val" എന്നതിന്റെ റഫറൻസ് എണ്ണം ഉചിതമായി വർദ്ധിപ്പിക്കുന്നതിന് ഉത്തരവാദിത്തമുണ്ട്
വിളിക്കുക, കൂടാതെ ഫംഗ്‌ഷൻ NULL നൽകുകയാണെങ്കിൽ അത് കുറയ്ക്കുന്നു. ഫലപ്രദമായി വിജയിച്ചു
hv_store "val" എന്നതിന്റെ ഒരു റഫറൻസിന്റെ ഉടമസ്ഥാവകാശം എടുക്കുന്നു. ഇത് സാധാരണയായി നിങ്ങൾ ചെയ്യുന്നതാണ്
ആഗ്രഹിക്കുന്നു; പുതുതായി സൃഷ്‌ടിച്ച എസ്‌വിക്ക് ഒന്നിന്റെ റഫറൻസ് എണ്ണം ഉണ്ട്, അതിനാൽ നിങ്ങളുടെ എല്ലാ കോഡും അങ്ങനെയാണെങ്കിൽ
SV-കൾ സൃഷ്‌ടിക്കുക, തുടർന്ന് അവ ഒരു ഹാഷിൽ സംഭരിക്കുക, hv_store-ന്റെ മാത്രം റഫറൻസ് സ്വന്തമാക്കും
പുതിയ SV, നിങ്ങളുടെ കോഡ് വൃത്തിയാക്കാൻ കൂടുതലൊന്നും ചെയ്യേണ്ടതില്ല. hv_store ആണ്
hv_store_ent എന്നതിലേക്കുള്ള ഒരു കോളായി നടപ്പിലാക്കിയിട്ടില്ല, കൂടാതെ ഇതിനായി ഒരു താൽക്കാലിക SV സൃഷ്ടിക്കുകയുമില്ല
കീ, അതിനാൽ നിങ്ങളുടെ കീ ഡാറ്റ ഇതിനകം SV ഫോമിൽ ഇല്ലെങ്കിൽ hv_store in ഉപയോഗിക്കുക
hv_store_ent-ന് മുൻഗണന.

കൂടുതൽ അറിയാൻ പെർൾഗട്ടിലെ "അണ്ടർസ്റ്റാൻഡിംഗ് ദി മാജിക് ഓഫ് ടൈഡ് ഹാഷുകളുടെയും അറേകളുടെയും" കാണുക
ടൈഡ് ഹാഷുകളിൽ ഈ ഫംഗ്‌ഷൻ എങ്ങനെ ഉപയോഗിക്കാം എന്നതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ.

SV** hv_store(HV *hv, കോൺസ്റ്റ് ചാർ *കീ, I32 klen,
SV *val, U32 ഹാഷ്)

hv_സ്റ്റോറുകൾ
"hv_store" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/നീളമുള്ള ജോഡിക്ക് പകരം ഒരു ലിറ്ററൽ സ്ട്രിംഗ് എടുക്കുന്നു
ഹാഷ് പാരാമീറ്റർ ഒഴിവാക്കുന്നു.

SV** hv_stores(HV* tb, const char* കീ,
NULLOK SV* val)

hv_store_ent
ഒരു ഹാഷിൽ "val" സംഭരിക്കുന്നു. ഹാഷ് കീ "കീ" എന്ന് വ്യക്തമാക്കിയിരിക്കുന്നു. "ഹാഷ്" പാരാമീറ്റർ
പ്രീകംപ്യൂട്ടഡ് ഹാഷ് മൂല്യമാണ്; ഇത് പൂജ്യമാണെങ്കിൽ, Perl അത് കണക്കാക്കും. ദി
അങ്ങനെ സൃഷ്ടിച്ച പുതിയ ഹാഷ് എൻട്രിയാണ് റിട്ടേൺ മൂല്യം. ഓപ്പറേഷൻ ആണെങ്കിൽ NULL ആയിരിക്കും
പരാജയപ്പെട്ടു അല്ലെങ്കിൽ മൂല്യം യഥാർത്ഥത്തിൽ ഹാഷിൽ സംഭരിക്കേണ്ട ആവശ്യമില്ലെങ്കിൽ (ഇത് പോലെ
ടൈഡ് ഹാഷുകളുടെ കേസ്). അല്ലെങ്കിൽ, റിട്ടേൺ മൂല്യത്തിന്റെ ഉള്ളടക്കങ്ങൾ ആകാം
"അവൻ?" ഉപയോഗിച്ച് ആക്സസ് ചെയ്തു ഇവിടെ വിവരിച്ചിരിക്കുന്ന മാക്രോകൾ. വിളിച്ചയാളാണ് എന്നത് ശ്രദ്ധിക്കുക
മുമ്പുള്ള "val" എന്നതിന്റെ റഫറൻസ് എണ്ണം ഉചിതമായി വർദ്ധിപ്പിക്കുന്നതിന് ഉത്തരവാദിത്തമുണ്ട്
വിളിക്കുക, കൂടാതെ ഫംഗ്‌ഷൻ NULL നൽകുകയാണെങ്കിൽ അത് കുറയ്ക്കുന്നു. ഫലപ്രദമായി വിജയിച്ചു
hv_store_ent "val" എന്നതിന്റെ ഒരു റഫറൻസിന്റെ ഉടമസ്ഥാവകാശം എടുക്കുന്നു. ഇത് സാധാരണയായി നിങ്ങൾ ചെയ്യുന്നതാണ്
ആഗ്രഹിക്കുന്നു; പുതുതായി സൃഷ്‌ടിച്ച എസ്‌വിക്ക് ഒന്നിന്റെ റഫറൻസ് എണ്ണം ഉണ്ട്, അതിനാൽ നിങ്ങളുടെ എല്ലാ കോഡും അങ്ങനെയാണെങ്കിൽ
SV-കൾ സൃഷ്‌ടിക്കുക, തുടർന്ന് അവ ഒരു ഹാഷിൽ സംഭരിക്കുക, hv_store-ന്റെ മാത്രം റഫറൻസ് സ്വന്തമാക്കും
പുതിയ SV, നിങ്ങളുടെ കോഡ് വൃത്തിയാക്കാൻ കൂടുതലൊന്നും ചെയ്യേണ്ടതില്ല. അതല്ല
hv_store_ent "കീ" മാത്രമേ വായിക്കൂ; "val" പോലെയല്ല, അത് അതിന്റെ ഉടമസ്ഥാവകാശം എടുക്കുന്നില്ല.
അതിനാൽ "കീ"യിലെ ശരിയായ റഫറൻസ് എണ്ണം നിലനിർത്തുന്നത് പൂർണ്ണമായും വിളിക്കുന്നയാളുടേതാണ്
ഉത്തരവാദിത്തം. hv_store_ent-ലേക്കുള്ള കോളായി hv_store നടപ്പിലാക്കിയിട്ടില്ല
കീയ്‌ക്കായി ഒരു താൽക്കാലിക എസ്‌വി സൃഷ്‌ടിക്കരുത്, അതിനാൽ നിങ്ങളുടെ കീ ഡാറ്റ ഇതിനകം എസ്‌വിയിൽ ഇല്ലെങ്കിൽ
ഫോം തുടർന്ന് hv_store_ent-ന് മുൻഗണനയായി hv_store ഉപയോഗിക്കുക.

കൂടുതൽ അറിയാൻ പെർൾഗട്ടിലെ "അണ്ടർസ്റ്റാൻഡിംഗ് ദി മാജിക് ഓഫ് ടൈഡ് ഹാഷുകളുടെയും അറേകളുടെയും" കാണുക
ടൈഡ് ഹാഷുകളിൽ ഈ ഫംഗ്‌ഷൻ എങ്ങനെ ഉപയോഗിക്കാം എന്നതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ.

HE* hv_store_ent(HV *hv, SV *key, SV *val, U32 ഹാഷ്)

hv_undef
ഹാഷ് നിർവചിക്കാതിരിക്കുന്നു. "undef(%hash)" എന്നതിന് തുല്യമായ XS.

അതുപോലെ ഹാഷിന്റെ എല്ലാ ഘടകങ്ങളും സ്വതന്ത്രമാക്കുന്നു (ഇത് പോലെ hv_clear()), ഇതും സ്വതന്ത്രമാക്കുന്നു
ഹാഷുമായി ബന്ധപ്പെട്ട ഏതെങ്കിലും സഹായ ഡാറ്റയും സംഭരണവും.

തിരിച്ചുവരുമ്പോൾ ഹാഷ് അസാധുവാകാനുള്ള സാധ്യതയെക്കുറിച്ചുള്ള കുറിപ്പിനായി "av_clear" കാണുക.

ശൂന്യമായ hv_undef(HV *hv)

newHV ഒരു പുതിയ HV സൃഷ്ടിക്കുന്നു. റഫറൻസ് എണ്ണം 1 ആയി സജ്ജീകരിച്ചിരിക്കുന്നു.

HV* newHV()

കൊളുത്ത് കൃത്രിമത്വം

ഈ ഫംഗ്‌ഷനുകൾ ഹുക്ക് വേരിയബിളുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള സൗകര്യപ്രദവും ത്രെഡ്-സുരക്ഷിതവുമായ മാർഗങ്ങൾ നൽകുന്നു.

wrap_op_checker
ഒരു നിർദ്ദിഷ്‌ട ഓപ് തരത്തിനായുള്ള ചെക്ക് ഫംഗ്‌ഷനുകളുടെ ശൃംഖലയിലേക്ക് ഒരു സി ഫംഗ്‌ഷൻ ഇടുന്നു. ഈ
"PL_check" അറേ കൈകാര്യം ചെയ്യുന്നതിനുള്ള മുൻഗണനാ മാർഗമാണ്. ഒപ്ചൊദെ ഏതാണെന്ന് വ്യക്തമാക്കുന്നു
ഒപിയുടെ തരം ബാധിക്കപ്പെടും. പുതിയ_ചെക്കർ സി ഫംഗ്‌ഷനിലേക്കുള്ള ഒരു പോയിന്ററാണ്
ആ ഒപ്‌കോഡിന്റെ ചെക്ക് ചെയിനിലേക്ക് ചേർക്കാൻ, ഒപ്പം പഴയ_ചെക്കർ_പി സംഭരണത്തിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്നു
ചെയിനിലെ അടുത്ത പ്രവർത്തനത്തിലേക്കുള്ള ഒരു പോയിന്റർ സംഭരിക്കുന്ന സ്ഥലം. ദി
ന്റെ മൂല്യം new_pointer മൂല്യം ആയിരിക്കുമ്പോൾ "PL_check" അറേയിൽ എഴുതിയിരിക്കുന്നു
മുമ്പ് അവിടെ സൂക്ഷിച്ചിരുന്നത് എന്നെഴുതിയതാണ് *old_checker_p.

പ്രവർത്തനം ഇതുപോലെ നിർവചിക്കണം:

സ്റ്റാറ്റിക് OP *new_checker(pTHX_ OP *op) { ...}

ഈ രീതിയിൽ വിളിക്കാൻ ഉദ്ദേശിക്കുന്നു:

new_checker(aTHX_ op)

പഴയ_ചെക്കർ_പി ഇതുപോലെ നിർവചിക്കേണ്ടതാണ്:

സ്റ്റാറ്റിക് Perl_check_t old_checker_p;

"PL_check" എന്നത് ഒരു മുഴുവൻ പ്രക്രിയയ്ക്കും ആഗോളമാണ്, ഒപ്പം ഹുക്ക് ഓപ്പുചെയ്യാൻ ആഗ്രഹിക്കുന്ന ഒരു മൊഡ്യൂളും
ഒരു പ്രക്രിയയ്‌ക്ക് ഒന്നിൽക്കൂടുതൽ പ്രാവശ്യം അഭ്യർത്ഥിച്ചതായി പരിശോധിക്കുന്നത് കണ്ടെത്തിയേക്കാം
വ്യത്യസ്ത ത്രെഡുകൾ. ആ സാഹചര്യം കൈകാര്യം ചെയ്യാൻ, ഈ ഫംഗ്‌ഷൻ ബുദ്ധിശൂന്യമാണ്. ദി
ലൊക്കേഷൻ *old_checker_p തുടക്കത്തിൽ (പ്രോസസ്സിന് ഒരിക്കൽ) ഒരു നൾ പോയിന്റർ അടങ്ങിയിരിക്കണം.
സ്റ്റാറ്റിക് ദൈർഘ്യത്തിന്റെ എസി വേരിയബിൾ (ഫയൽ സ്കോപ്പിൽ പ്രഖ്യാപിച്ചു, സാധാരണയായി അടയാളപ്പെടുത്തിയിരിക്കുന്നു
ആന്തരിക ലിങ്കേജ് നൽകുന്നതിന് "സ്റ്റാറ്റിക്") പരോക്ഷമായി ആരംഭിക്കും
ഉചിതമായി, അതിന് വ്യക്തമായ ഒരു ഇനീഷ്യലൈസർ ഇല്ലെങ്കിൽ. ഈ പ്രവർത്തനം ചെയ്യും
ചെക്ക് ചെയിൻ കണ്ടെത്തുകയാണെങ്കിൽ മാത്രമേ യഥാർത്ഥത്തിൽ പരിഷ്ക്കരിക്കുക *old_checker_p ശൂന്യമാകാൻ. ഈ
ഫംഗ്ഷൻ ചെറിയ തോതിൽ ത്രെഡ് സുരക്ഷിതമാണ്. ഇത് ഉചിതമായ ലോക്കിംഗ് ഉപയോഗിക്കുന്നു
"PL_check" ആക്സസ് ചെയ്യുന്നതിൽ റേസ് സാഹചര്യങ്ങൾ ഒഴിവാക്കുക.

ഈ ഫംഗ്‌ഷൻ വിളിക്കുമ്പോൾ, ഫംഗ്‌ഷൻ പരാമർശിക്കുന്നത് പുതിയ_ചെക്കർ തയ്യാറായിരിക്കണം
ഒഴികെ വിളിക്കപ്പെടണം *old_checker_p നികത്തപ്പെടാതെ കിടക്കുന്നു. ഒരു ത്രെഡിംഗ് സാഹചര്യത്തിൽ,
പുതിയ_ചെക്കർ ഈ ഫംഗ്‌ഷൻ തിരികെ വരുന്നതിന് മുമ്പുതന്നെ, ഉടനടി വിളിച്ചേക്കാം.
*old_checker_p എല്ലായ്പ്പോഴും ഉചിതമായി മുമ്പ് സജ്ജീകരിക്കും പുതിയ_ചെക്കർ വിളിച്ചു. എങ്കിൽ
പുതിയ_ചെക്കർ നൽകിയിരിക്കുന്ന ഒരു ഓപ്‌ ഉപയോഗിച്ച് പ്രത്യേകമായി ഒന്നും ചെയ്യേണ്ടതില്ലെന്ന് തീരുമാനിക്കുന്നു (ഏത്
ഒപ് ചെക്ക് ഹുക്കിംഗിന്റെ മിക്ക ഉപയോഗങ്ങൾക്കും ഇത് സാധാരണ സംഭവമാണ്), ഇത് ചെക്ക് ചെയിൻ ചെയ്യണം
ഫംഗ്ഷൻ പരാമർശിച്ചത് *old_checker_p.

ഒരു നിർദ്ദിഷ്‌ട സബ്‌റൂട്ടീനിലേക്കുള്ള കോളുകളുടെ സമാഹാരത്തെ സ്വാധീനിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ഉപയോഗിക്കുക
"cv_set_call_checker" എല്ലാ "entersub" ഓപ്‌സുകളുടെയും ഹുക്ക് ചെക്കിംഗിന് പകരം.

void wrap_op_checker(ഒപ്‌ടൈപ്പ് ഒപ്‌കോഡ്,
Perl_check_t new_checker,
Perl_check_t *old_checker_p)

ലെക്സർ ഇന്റർഫേസ്

പ്രതീകങ്ങളും ടോക്കണുകളും നിയന്ത്രിക്കുന്ന പേൾ പാർസറിന്റെ താഴത്തെ പാളിയാണിത്.

lex_bufutf8
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ലെക്‌സർ ബഫറിലെ ഒക്‌റ്ററ്റുകൾ ("PL_parser->linestr") ആയിരിക്കണമോ എന്ന് സൂചിപ്പിക്കുന്നു
യൂണികോഡ് പ്രതീകങ്ങളുടെ UTF-8 എൻകോഡിംഗ് ആയി വ്യാഖ്യാനിക്കുന്നു. ഇല്ലെങ്കിൽ, അവർ ആയിരിക്കണം
ലാറ്റിൻ-1 പ്രതീകങ്ങളായി വ്യാഖ്യാനിക്കുന്നു. ഇത് "SvUTF8" ഫ്ലാഗിന് സമാനമാണ്
സ്കെയിലറുകൾ.

UTF-8 മോഡിൽ, ലെക്‌സർ ബഫറിൽ യഥാർത്ഥത്തിൽ സാധുത ഉണ്ടെന്ന് ഉറപ്പില്ല
UTF-8. അസാധുവായ എൻകോഡിംഗിന്റെ പശ്ചാത്തലത്തിൽ ലെക്സിംഗ് കോഡ് ശക്തമായിരിക്കണം.

"PL_parser->linestr" സ്കെയിലറിന്റെ യഥാർത്ഥ "SvUTF8" ഫ്ലാഗ് പ്രധാനമാണ്, പക്ഷേ
ഇൻപുട്ട് പ്രതീക എൻകോഡിംഗുമായി ബന്ധപ്പെട്ട മുഴുവൻ കഥയും അല്ല. സാധാരണയായി, ഒരു ഫയൽ ചെയ്യുമ്പോൾ
വായിക്കുന്നു, സ്കെലാറിൽ ഒക്ടറ്റുകൾ അടങ്ങിയിരിക്കുന്നു, അതിന്റെ "SvUTF8" ഫ്ലാഗ് ഓഫാണ്, പക്ഷേ
"Use utf8" പ്രാഗ്മ പ്രാബല്യത്തിലാണെങ്കിൽ ഒക്ടറ്റുകളെ UTF-8 ആയി വ്യാഖ്യാനിക്കണം.
എന്നിരുന്നാലും, ഒരു സ്ട്രിംഗ് എവൽ സമയത്ത്, സ്കെലാറിന് "SvUTF8" ഫ്ലാഗ് ഓണാക്കിയേക്കാം
ഈ സാഹചര്യത്തിൽ, "ഉപയോഗ ബൈറ്റുകൾ" പ്രാഗ്മ ഇല്ലെങ്കിൽ അതിന്റെ ഒക്ടറ്റുകളെ UTF-8 ആയി വ്യാഖ്യാനിക്കണം.
പ്രാബല്യത്തിൽ ഉണ്ട്. ഭാവിയിൽ ഈ യുക്തി മാറിയേക്കാം; പകരം ഈ ഫംഗ്ഷൻ ഉപയോഗിക്കുക
യുക്തി സ്വയം നടപ്പിലാക്കുന്നു.

bool lex_bufutf8()

lex_discard_to
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

വരെ "PL_parser->linestr" ബഫറിന്റെ ആദ്യ ഭാഗം നിരസിക്കുന്നു പിടിആർ. ദി
ബഫറിന്റെ ശേഷിക്കുന്ന ഉള്ളടക്കം നീക്കും, കൂടാതെ എല്ലാ പോയിന്ററുകളും ബഫറിലേക്ക് മാറ്റും
ഉചിതമായി അപ്ഡേറ്റ് ചെയ്തു. പിടിആർ എന്ന സ്ഥാനത്തേക്കാൾ പിന്നീട് ബഫറിൽ ആയിരിക്കരുത്
"PL_parser->bufptr": ഇനിയും lexed ചെയ്യപ്പെടാത്ത വാചകം നിരസിക്കാൻ ഇതിന് അനുവാദമില്ല.

സാധാരണയായി ഇത് നേരിട്ട് ചെയ്യണമെന്നില്ല, കാരണം ഇത് ഉപയോഗിച്ചാൽ മതിയാകും
"lex_next_chunk" എന്നതിന്റെ പരോക്ഷമായ നിരസിക്കുന്ന സ്വഭാവവും അതിനെ അടിസ്ഥാനമാക്കിയുള്ള കാര്യങ്ങളും.
എന്നിരുന്നാലും, ഒരു ടോക്കൺ ഒന്നിലധികം ലൈനുകളിൽ വ്യാപിക്കുകയും ലെക്സിംഗ് കോഡ് നിലനിർത്തുകയും ചെയ്താൽ
അതിനായി ബഫറിൽ ഒന്നിലധികം വരികൾ, തുടർന്ന് പൂർത്തിയാക്കിയ ശേഷം
ടോക്കൺ, ഇപ്പോൾ ആവശ്യമില്ലാത്ത മുൻ വരികൾ വ്യക്തമായി നിരസിക്കുന്നതാണ് ബുദ്ധി,
ഭാവിയിൽ മൾട്ടി-ലൈൻ ടോക്കണുകൾ ബഫർ കെട്ടാതെ വളരുന്നത് ഒഴിവാക്കാൻ.

അസാധുവായ lex_discard_to(char *ptr)

lex_grow_linestr
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

കുറഞ്ഞത് ഉൾക്കൊള്ളാൻ ലെക്സർ ബഫർ ("PL_parser->linestr") വീണ്ടും അനുവദിക്കുക ലെൻ
ഒക്ടറ്റുകൾ ("NUL" അവസാനിപ്പിക്കുന്നത് ഉൾപ്പെടെ). വീണ്ടും അനുവദിച്ചതിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു
ബഫർ. ബഫറിന്റെ നേരിട്ടുള്ള മാറ്റം വരുത്തുന്നതിന് മുമ്പ് ഇത് ആവശ്യമാണ്
അത് അതിന്റെ നീളം കൂട്ടും. "lex_stuff_pvn" കൂടുതൽ സൗകര്യപ്രദമായ മാർഗം നൽകുന്നു
ബഫറിലേക്ക് വാചകം ചേർക്കുക.

"PL_parser->linestr"-ൽ നേരിട്ട് "SvGROW" അല്ലെങ്കിൽ "sv_grow" ഉപയോഗിക്കരുത്; ഈ പ്രവർത്തനം
ബഫറിലേക്ക് നേരിട്ട് പോയിന്റ് ചെയ്യുന്ന ലെക്സറിന്റെ എല്ലാ വേരിയബിളുകളും അപ്ഡേറ്റ് ചെയ്യുന്നു.

char * lex_grow_linestr(STRLEN ലെൻ)

lex_next_chunk
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

"PL_parser->linestr" ലേക്ക് കൂട്ടിച്ചേർത്ത്, ലെക്‌സ് ചെയ്യേണ്ട ടെക്‌സ്‌റ്റിന്റെ അടുത്ത ഭാഗത്തിൽ വായിക്കുന്നു.
ലെക്സിംഗ് കോഡ് നിലവിലെ ചങ്കിന്റെ അവസാനത്തിലേക്ക് നോക്കുമ്പോൾ ഇത് വിളിക്കണം
കൂടുതൽ അറിയാൻ ആഗ്രഹിക്കുന്നു. ലെക്സിംഗിന് ഇത് സാധാരണമാണ്, പക്ഷേ ആവശ്യമില്ല
ഈ സമയത്ത് നിലവിലെ ചങ്ക് മുഴുവനും കഴിച്ചു.

"PL_parser->bufptr" എന്നത് നിലവിലെ ചങ്കിന്റെ അവസാന ഭാഗത്തേക്കാണ് വിരൽ ചൂണ്ടുന്നതെങ്കിൽ (അതായത്,
നിലവിലെ ചങ്ക് പൂർണ്ണമായും ഉപയോഗിച്ചു), സാധാരണയായി നിലവിലെ ചങ്ക് ആയിരിക്കും
പുതിയ ചങ്ക് വായിക്കുന്ന അതേ സമയം നിരസിച്ചു. എങ്കിൽ ഫ്ലാഗുകൾ ഉൾപ്പെടുന്നു
"LEX_KEEP_PREVIOUS", നിലവിലെ ഭാഗം ഉപേക്ഷിക്കില്ല. കറന്റ് ആണെങ്കിൽ
ചങ്ക് പൂർണ്ണമായി കഴിച്ചിട്ടില്ല, പിന്നെ അത് പരിഗണിക്കാതെ തന്നെ ഉപേക്ഷിക്കില്ല
കൊടി.

ബഫറിൽ എന്തെങ്കിലും പുതിയ ടെക്‌സ്‌റ്റ് ചേർത്തിട്ടുണ്ടെങ്കിൽ true എന്ന് നൽകുന്നു, അല്ലെങ്കിൽ ബഫറിൽ ഉണ്ടെങ്കിൽ തെറ്റ്
ഇൻപുട്ട് വാചകത്തിന്റെ അവസാനം എത്തി.

bool lex_next_chunk (U32 ഫ്ലാഗുകൾ)

lex_peek_unichar
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

നിലവിൽ ലെക്‌സ് ചെയ്‌തിരിക്കുന്ന വാചകത്തിലെ ഒരു (യൂണികോഡ്) പ്രതീകം മുന്നിൽ കാണുന്നു. മടങ്ങുന്നു
അടുത്ത പ്രതീകത്തിന്റെ കോഡ്‌പോയിന്റ് (ഒപ്പ് ചെയ്യാത്ത പൂർണ്ണസംഖ്യ മൂല്യം), അല്ലെങ്കിൽ lexing ഉണ്ടെങ്കിൽ -1
ഇൻപുട്ട് വാചകത്തിന്റെ അവസാനം എത്തി. ഒളിഞ്ഞിരിക്കുന്ന പ്രതീകം ഉപഭോഗം ചെയ്യാൻ, ഉപയോഗിക്കുക
"lex_read_unichar".

അടുത്ത പ്രതീകം ഇൻപുട്ട് ടെക്‌സ്‌റ്റിന്റെ അടുത്ത ഭാഗത്തിലാണെങ്കിൽ (അല്ലെങ്കിൽ അതിലേക്ക് വ്യാപിക്കുന്നു), the
അടുത്ത ചങ്ക് വായിക്കും. സാധാരണയായി നിലവിലെ ചങ്ക് ഇവിടെ ഉപേക്ഷിക്കപ്പെടും
അതേ സമയം, എന്നാൽ എങ്കിൽ ഫ്ലാഗുകൾ "LEX_KEEP_PREVIOUS" ഉൾപ്പെടുന്നു, തുടർന്ന് നിലവിലെ ഭാഗം ചെയ്യും
തള്ളിക്കളയരുത്.

ഇൻപുട്ട് UTF-8 ആയി വ്യാഖ്യാനിക്കുകയും UTF-8 എൻകോഡിംഗ് പിശക് ആണെങ്കിൽ
കണ്ടുമുട്ടി, ഒരു അപവാദം സൃഷ്ടിക്കപ്പെടുന്നു.

I32 lex_peek_unichar(U32 പതാകകൾ)

lex_read_space
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

നിലവിൽ ലെക്‌സ് ചെയ്‌തിരിക്കുന്ന ടെക്‌സ്‌റ്റിൽ പേൾ ശൈലിയിൽ ഓപ്‌ഷണൽ സ്‌പെയ്‌സുകൾ വായിക്കുന്നു. ദി
സ്‌പെയ്‌സിൽ സാധാരണ വൈറ്റ്‌സ്‌പേസ് പ്രതീകങ്ങളും പേൾ ശൈലിയിലുള്ള കമന്റുകളും ഉൾപ്പെട്ടേക്കാം.
"#ലൈൻ" നിർദ്ദേശങ്ങൾ നേരിടുകയാണെങ്കിൽ പ്രോസസ്സ് ചെയ്യപ്പെടും. "PL_parser->bufptr" നീക്കി
സ്‌പെയ്‌സുകൾ കഴിഞ്ഞാൽ, അത് ഒരു നോൺ-സ്‌പേസ് പ്രതീകത്തിലേക്ക് (അല്ലെങ്കിൽ അതിന്റെ അവസാനം) പോയിന്റ് ചെയ്യുന്നു
ഇൻപുട്ട് ടെക്സ്റ്റ്).

ഇൻപുട്ട് ടെക്‌സ്‌റ്റിന്റെ അടുത്ത ഭാഗത്തേക്ക് സ്‌പെയ്‌സുകൾ വ്യാപിക്കുകയാണെങ്കിൽ, അടുത്ത ഭാഗം വായിക്കും
ഇൻ. സാധാരണയായി നിലവിലെ ചങ്ക് ഒരേ സമയം ഉപേക്ഷിക്കപ്പെടും, എന്നാൽ എങ്കിൽ ഫ്ലാഗുകൾ
"LEX_KEEP_PREVIOUS" ഉൾപ്പെടുത്തിയാൽ നിലവിലെ ഭാഗം ഉപേക്ഷിക്കില്ല.

ശൂന്യമായ lex_read_space(U32 ഫ്ലാഗുകൾ)

lex_read_to
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ലെക്‌സർ ബഫറിൽ "PL_parser->bufptr" മുതൽ വരെ ടെക്‌സ്‌റ്റ് ഉപയോഗിക്കുക പിടിആർ. ഈ
പൊരുത്തപ്പെടുത്തുന്നതിന് "PL_parser->bufptr" മുന്നേറുന്നു പിടിആർ, ശരിയായ ബുക്ക് കീപ്പിംഗ് നടത്തുന്നു
ഒരു പുതിയ ലൈൻ പ്രതീകം കടന്നുപോകുമ്പോഴെല്ലാം. ലെക്സഡ് കഴിക്കുന്നതിനുള്ള സാധാരണ മാർഗമാണിത്
വാചകം.

ചെറുതായി ഉപയോഗിച്ചുകൊണ്ട് ബഫറിന്റെ ഒക്ടറ്റുകളുടെ വ്യാഖ്യാനം അമൂർത്തമാക്കാവുന്നതാണ്
ഉയർന്ന തലത്തിലുള്ള പ്രവർത്തനങ്ങൾ "lex_peek_unichar", "lex_read_unichar" എന്നിവ.

അസാധുവായ lex_read_to(char *ptr)

lex_read_unichar
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

നിലവിൽ ലെക്‌സ് ചെയ്‌തിരിക്കുന്ന വാചകത്തിലെ അടുത്ത (യൂണികോഡ്) പ്രതീകം വായിക്കുന്നു. തിരികെ നൽകുന്നു
പ്രതീകം വായിക്കുകയും നീക്കുകയും ചെയ്യുന്നതിന്റെ കോഡ്‌പോയിന്റ് (ഒപ്പ് ചെയ്യാത്ത പൂർണ്ണസംഖ്യ മൂല്യം).
"PL_parser->bufptr" പ്രതീകം കഴിഞ്ഞോ, അല്ലെങ്കിൽ lexing എത്തിയാൽ -1 നൽകുന്നു
ഇൻപുട്ട് വാചകത്തിന്റെ അവസാനം. അടുത്ത പ്രതീകത്തെ നശിപ്പിക്കാതെ പരിശോധിക്കാൻ, ഉപയോഗിക്കുക
പകരം "lex_peek_unichar".

അടുത്ത പ്രതീകം ഇൻപുട്ട് ടെക്‌സ്‌റ്റിന്റെ അടുത്ത ഭാഗത്തിലാണെങ്കിൽ (അല്ലെങ്കിൽ അതിലേക്ക് വ്യാപിക്കുന്നു), the
അടുത്ത ചങ്ക് വായിക്കും. സാധാരണയായി നിലവിലെ ചങ്ക് ഇവിടെ ഉപേക്ഷിക്കപ്പെടും
അതേ സമയം, എന്നാൽ എങ്കിൽ ഫ്ലാഗുകൾ "LEX_KEEP_PREVIOUS" ഉൾപ്പെടുന്നു, തുടർന്ന് നിലവിലെ ഭാഗം ചെയ്യും
തള്ളിക്കളയരുത്.

ഇൻപുട്ട് UTF-8 ആയി വ്യാഖ്യാനിക്കുകയും UTF-8 എൻകോഡിംഗ് പിശക് ആണെങ്കിൽ
കണ്ടുമുട്ടി, ഒരു അപവാദം സൃഷ്ടിക്കപ്പെടുന്നു.

I32 lex_read_unichar(U32 ഫ്ലാഗുകൾ)

lex_start
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു പുതിയ ലെക്‌സർ/പാഴ്‌സർ സ്റ്റേറ്റ് ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുകയും ആരംഭിക്കുകയും ചെയ്യുന്നു, ഇത് ഒരു സന്ദർഭം നൽകുന്നു
പേൾ കോഡിന്റെ ഒരു പുതിയ ഉറവിടത്തിൽ നിന്ന് ലെക്‌സ് ചെയ്യാനും പാഴ്‌സ് ചെയ്യാനും. പുതിയ സംസ്ഥാനത്തിലേക്കുള്ള ഒരു സൂചന
ഒബ്ജക്റ്റ് "PL_parser" ൽ സ്ഥാപിച്ചിരിക്കുന്നു. സേവ് സ്റ്റാക്കിൽ ഒരു എൻട്രി ഉണ്ടാക്കിയിരിക്കുന്നു
പുതിയ സ്റ്റേറ്റ് ഒബ്ജക്റ്റ് അഴിച്ചുമാറ്റുന്നത്, അതിന്റെ മുൻ മൂല്യം നശിപ്പിക്കപ്പെടും
"PL_parser" പുനഃസ്ഥാപിക്കപ്പെടും. പാഴ്‌സിംഗ് വൃത്തിയാക്കാൻ മറ്റൊന്നും ചെയ്യേണ്ടതില്ല
സന്ദർഭം.

പാഴ്‌സ് ചെയ്യേണ്ട കോഡ് വരുന്നത് വര ഒപ്പം ആർഎസ്എഫ്പി. വര, അസാധുവാണെങ്കിൽ, a നൽകുന്നു
പാഴ്‌സ് ചെയ്യേണ്ട കോഡ് അടങ്ങിയ സ്‌ട്രിംഗ് (എസ്‌വി രൂപത്തിൽ). സ്ട്രിംഗിന്റെ ഒരു പകർപ്പ് നിർമ്മിച്ചു,
അതിനാൽ തുടർന്നുള്ള പരിഷ്ക്കരണം വര പാഴ്സിംഗിനെ ബാധിക്കില്ല. ആർഎസ്എഫ്പി, അസാധുവാണെങ്കിൽ,
പാഴ്‌സ് ചെയ്യാൻ കോഡ് വായിക്കുന്ന ഒരു ഇൻപുട്ട് സ്ട്രീം നൽകുന്നു. രണ്ടും ആണെങ്കിൽ
അസാധുവായ, കോഡ് ഇൻ വര ആദ്യം വരുന്നു, പൂർണ്ണമായ വരികൾ അടങ്ങിയിരിക്കണം
ഇൻപുട്ട്, ഒപ്പം ആർഎസ്എഫ്പി ഉറവിടത്തിന്റെ ശേഷിക്കുന്ന ഭാഗം നൽകുന്നു.

ദി ഫ്ലാഗുകൾ ഭാവിയിലെ ഉപയോഗത്തിനായി പാരാമീറ്റർ കരുതിവച്ചിരിക്കുന്നു. നിലവിൽ ഇത് perl മാത്രമാണ് ഉപയോഗിക്കുന്നത്
ആന്തരികമായി, അതിനാൽ വിപുലീകരണങ്ങൾ എല്ലായ്പ്പോഴും പൂജ്യം കടന്നുപോകണം.

ശൂന്യമായ lex_start(SV *line, PerlIO *rsfp, U32 ഫ്ലാഗുകൾ)

lex_stuff_pv
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഉടൻ തന്നെ ലെക്സർ ബഫറിൽ ("PL_parser->linestr") പ്രതീകങ്ങൾ ചേർക്കുക
നിലവിലെ ലെക്സിംഗ് പോയിന്റ് ("PL_parser->bufptr"), എങ്കിൽ ബഫർ വീണ്ടും ലൊക്കേറ്റ് ചെയ്യുന്നു
ആവശ്യമായ. ഇതിനർത്ഥം പിന്നീട് പ്രവർത്തിക്കുന്ന ലെക്സിംഗ് കോഡ് പ്രതീകങ്ങളെ ഇങ്ങനെ കാണുമെന്നാണ്
അവ ഇൻപുട്ടിൽ പ്രത്യക്ഷപ്പെട്ടിരുന്നെങ്കിൽ. ഭാഗമായി ഇത് ചെയ്യാൻ ശുപാർശ ചെയ്തിട്ടില്ല
സാധാരണ പാഴ്‌സിംഗ്, കൂടാതെ ഈ സൗകര്യത്തിന്റെ മിക്ക ഉപയോഗങ്ങളും ഉൾപ്പെടുത്തിയതിന്റെ അപകടസാധ്യത പ്രവർത്തിപ്പിക്കുന്നു
പ്രതീകങ്ങൾ ഉദ്ദേശിക്കാത്ത രീതിയിൽ വ്യാഖ്യാനിക്കപ്പെടുന്നു.

ചേർക്കേണ്ട സ്ട്രിംഗിനെ പ്രതിനിധീകരിക്കുന്നത് ഒക്‌റ്ററ്റുകളിൽ നിന്ന് ആരംഭിക്കുന്നു pv തുടരുകയും ചെയ്യുന്നു
ആദ്യ nul ലേക്ക്. ഈ ഒക്ടറ്റുകളെ UTF-8 അല്ലെങ്കിൽ ലാറ്റിൻ-1 ആയി വ്യാഖ്യാനിക്കുന്നു,
"LEX_STUFF_UTF8" ഫ്ലാഗ് സജ്ജീകരിച്ചിട്ടുണ്ടോ എന്നതനുസരിച്ച് ഫ്ലാഗുകൾ. കഥാപാത്രങ്ങള്
നിലവിൽ ബഫർ എങ്ങനെയിരിക്കുന്നു എന്നതനുസരിച്ച്, ലെക്‌സർ ബഫറിനായി റീകോഡ് ചെയ്‌തിരിക്കുന്നു
വ്യാഖ്യാനിച്ചു ("lex_bufutf8"). ഒരു സ്ട്രിംഗ് അസാധുവാക്കുന്നത് സൗകര്യപ്രദമല്ലെങ്കിൽ
ചേർക്കുക, "lex_stuff_pvn" ഫംഗ്‌ഷൻ കൂടുതൽ അനുയോജ്യമാണ്.

void lex_stuff_pv (const char *pv, U32 ഫ്ലാഗുകൾ)

lex_stuff_pvn
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഉടൻ തന്നെ ലെക്സർ ബഫറിൽ ("PL_parser->linestr") പ്രതീകങ്ങൾ ചേർക്കുക
നിലവിലെ ലെക്സിംഗ് പോയിന്റ് ("PL_parser->bufptr"), എങ്കിൽ ബഫർ വീണ്ടും ലൊക്കേറ്റ് ചെയ്യുന്നു
ആവശ്യമായ. ഇതിനർത്ഥം പിന്നീട് പ്രവർത്തിക്കുന്ന ലെക്സിംഗ് കോഡ് പ്രതീകങ്ങളെ ഇങ്ങനെ കാണുമെന്നാണ്
അവ ഇൻപുട്ടിൽ പ്രത്യക്ഷപ്പെട്ടിരുന്നെങ്കിൽ. ഭാഗമായി ഇത് ചെയ്യാൻ ശുപാർശ ചെയ്തിട്ടില്ല
സാധാരണ പാഴ്‌സിംഗ്, കൂടാതെ ഈ സൗകര്യത്തിന്റെ മിക്ക ഉപയോഗങ്ങളും ഉൾപ്പെടുത്തിയതിന്റെ അപകടസാധ്യത പ്രവർത്തിപ്പിക്കുന്നു
പ്രതീകങ്ങൾ ഉദ്ദേശിക്കാത്ത രീതിയിൽ വ്യാഖ്യാനിക്കപ്പെടുന്നു.

ചേർക്കേണ്ട സ്ട്രിംഗ് പ്രതിനിധീകരിക്കുന്നത് ലെൻ ഒക്ടറ്റുകളിൽ ആരംഭിക്കുന്നു pv. ഇവ
ഒക്ടറ്റുകളെ UTF-8 അല്ലെങ്കിൽ ലാറ്റിൻ-1 ആയി വ്യാഖ്യാനിക്കുന്നു
"LEX_STUFF_UTF8" ഫ്ലാഗ് സജ്ജീകരിച്ചിരിക്കുന്നു ഫ്ലാഗുകൾ. അക്ഷരങ്ങൾ ലെക്‌സർക്കായി വീണ്ടും കോഡ് ചെയ്‌തിരിക്കുന്നു
ബഫർ, ബഫർ നിലവിൽ എങ്ങനെ വ്യാഖ്യാനിക്കപ്പെടുന്നു എന്നതനുസരിച്ച്
("lex_bufutf8"). ചേർക്കേണ്ട ഒരു സ്ട്രിംഗ് ഒരു പേൾ സ്കെയിലറായി ലഭ്യമാണെങ്കിൽ, the
"lex_stuff_sv" ഫംഗ്‌ഷൻ കൂടുതൽ സൗകര്യപ്രദമാണ്.

void lex_stuff_pvn(const char *pv, STRLEN ലെൻ,
U32 പതാകകൾ)

lex_stuff_pvs
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

"lex_stuff_pvn" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/ലെംഗ്ത്ത് ജോഡിക്ക് പകരം ഒരു ലിറ്ററൽ സ്ട്രിംഗ് എടുക്കുന്നു.

void lex_stuff_pvs(const char *pv, U32 ഫ്ലാഗുകൾ)

lex_stuff_sv
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഉടൻ തന്നെ ലെക്സർ ബഫറിൽ ("PL_parser->linestr") പ്രതീകങ്ങൾ ചേർക്കുക
നിലവിലെ ലെക്സിംഗ് പോയിന്റ് ("PL_parser->bufptr"), എങ്കിൽ ബഫർ വീണ്ടും ലൊക്കേറ്റ് ചെയ്യുന്നു
ആവശ്യമായ. ഇതിനർത്ഥം പിന്നീട് പ്രവർത്തിക്കുന്ന ലെക്സിംഗ് കോഡ് പ്രതീകങ്ങളെ ഇങ്ങനെ കാണുമെന്നാണ്
അവ ഇൻപുട്ടിൽ പ്രത്യക്ഷപ്പെട്ടിരുന്നെങ്കിൽ. ഭാഗമായി ഇത് ചെയ്യാൻ ശുപാർശ ചെയ്തിട്ടില്ല
സാധാരണ പാഴ്‌സിംഗ്, കൂടാതെ ഈ സൗകര്യത്തിന്റെ മിക്ക ഉപയോഗങ്ങളും ഉൾപ്പെടുത്തിയതിന്റെ അപകടസാധ്യത പ്രവർത്തിപ്പിക്കുന്നു
പ്രതീകങ്ങൾ ഉദ്ദേശിക്കാത്ത രീതിയിൽ വ്യാഖ്യാനിക്കപ്പെടുന്നു.

ചേർക്കേണ്ട സ്‌ട്രിംഗ് അതിന്റെ സ്‌ട്രിംഗ് മൂല്യമാണ് sv. കഥാപാത്രങ്ങൾ റീകോഡ് ചെയ്തിട്ടുണ്ട്
ലെക്‌സർ ബഫറിനായി, ബഫർ നിലവിൽ എങ്ങനെ വ്യാഖ്യാനിക്കപ്പെടുന്നു എന്നതനുസരിച്ച്
("lex_bufutf8"). ചേർക്കേണ്ട ഒരു സ്ട്രിംഗ് ഇതിനകം ഒരു പേൾ സ്കെയിലർ അല്ലെങ്കിൽ, ദി
"lex_stuff_pvn" ഫംഗ്ഷൻ ഒരു സ്കെയിലർ നിർമ്മിക്കേണ്ടതിന്റെ ആവശ്യകത ഒഴിവാക്കുന്നു.

void lex_stuff_sv(SV *sv, U32 ഫ്ലാഗുകൾ)

lex_unstuff
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

"PL_parser->bufptr" മുതൽ വരെ ലെക്‌സ് ചെയ്യാൻ പോകുന്ന വാചകം നിരസിക്കുന്നു പിടിആർ. വാചകം
പിന്തുടരുന്ന പിടിആർ നീക്കപ്പെടും, ബഫർ ചുരുക്കും. ഇത് ഉപേക്ഷിച്ചവ മറയ്ക്കുന്നു
ടെക്‌സ്‌റ്റ് ഒരിക്കലും പ്രത്യക്ഷപ്പെട്ടിട്ടില്ലെന്ന മട്ടിൽ പിന്നീട് പ്രവർത്തിക്കുന്ന ഏതെങ്കിലും ലെക്സിംഗ് കോഡിൽ നിന്നുള്ള വാചകം.

ലെക്സഡ് ടെക്സ്റ്റ് ഉപയോഗിക്കുന്നതിനുള്ള സാധാരണ രീതിയല്ല ഇത്. അതിനായി, "lex_read_to" ഉപയോഗിക്കുക.

ശൂന്യമായ lex_unstuff(char *ptr)

parse_arithexpr
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു പേൾ ഗണിത പദപ്രയോഗം പാഴ്‌സ് ചെയ്യുക. ഇതിൽ മുൻ‌ഗണന ഡൗൺ ഓപ്പറേറ്റർമാർ അടങ്ങിയിരിക്കാം
ബിറ്റ് ഷിഫ്റ്റ് ഓപ്പറേറ്റർമാർക്ക്. പദപ്രയോഗം പിന്തുടരേണ്ടതുണ്ട് (അങ്ങനെ അവസാനിപ്പിക്കുക)
ഒന്നുകിൽ ഒരു താരതമ്യത്തിലൂടെയോ താഴ്ന്ന മുൻഗണനാ ഓപ്പറേറ്ററിലൂടെയോ അല്ലെങ്കിൽ എന്തെങ്കിലും വഴിയോ
സാധാരണയായി അർദ്ധവിരാമം പോലുള്ള ഒരു പദപ്രയോഗം അവസാനിപ്പിക്കുക. എങ്കിൽ ഫ്ലാഗുകൾ ഉൾപ്പെടുന്നു
"PARSE_OPTIONAL" അപ്പോൾ എക്സ്പ്രഷൻ ഓപ്ഷണലാണ്, അല്ലാത്തപക്ഷം അത് നിർബന്ധമാണ്. അത്
ഡൈനാമിക് പാഴ്സർ നില ("PL_parser" et al) ആണെന്ന് ഉറപ്പാക്കാൻ വിളിക്കുന്നയാളാണ്
പാഴ്‌സ് ചെയ്യേണ്ട കോഡിന്റെ ഉറവിടവും ലെക്സിക്കലും പ്രതിഫലിപ്പിക്കുന്നതിന് ശരിയായി സജ്ജീകരിച്ചിരിക്കുന്നു
ആവിഷ്കാരത്തിനുള്ള സന്ദർഭം.

പദപ്രയോഗത്തെ പ്രതിനിധീകരിക്കുന്ന ഓപ് ട്രീ തിരികെ നൽകി. ഒരു ഓപ്ഷണൽ എക്സ്പ്രഷൻ ആണെങ്കിൽ
ഇല്ലെങ്കിൽ, ഒരു നൾ പോയിന്റർ തിരികെ നൽകും, അല്ലാത്തപക്ഷം പോയിന്റർ അസാധുവായതായിരിക്കും.

പാഴ്‌സിംഗിലോ സമാഹാരത്തിലോ ഒരു പിശക് സംഭവിക്കുകയാണെങ്കിൽ, മിക്ക കേസുകളിലും ഒരു സാധുവായ ഓപ് ട്രീ ആയിരിക്കും
എന്തായാലും മടങ്ങി. പിശക് പാഴ്സർ അവസ്ഥയിൽ പ്രതിഫലിക്കുന്നു, സാധാരണയായി ഫലം
എല്ലാ കംപൈലേഷനും ഉൾക്കൊള്ളുന്ന പാഴ്‌സിംഗിന്റെ ഉയർന്ന തലത്തിൽ ഒരൊറ്റ ഒഴിവാക്കലിൽ
സംഭവിച്ച പിശകുകൾ. എന്നിരുന്നാലും ചില കംപൈലേഷൻ പിശകുകൾ ഒരു അപവാദം ഉണ്ടാക്കും
ഉടനെ.

OP * parse_arithexpr(U32 ഫ്ലാഗുകൾ)

parse_barestmt
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

അലങ്കരിച്ച ഒരു പെർൾ പ്രസ്താവന പാഴ്‌സ് ചെയ്യുക. ഇത് ഒരു സാധാരണ അനിവാര്യതയായിരിക്കാം
കംപൈൽ-ടൈം ഇഫക്റ്റ് ഉള്ള ഒരു പ്രസ്താവന അല്ലെങ്കിൽ ഒരു പ്രഖ്യാപനം. അതിൽ ഒന്നും ഉൾപ്പെടുന്നില്ല
ലേബൽ അല്ലെങ്കിൽ മറ്റ് അഫിക്സ്ചർ. ഡൈനാമിക് എന്ന് ഉറപ്പ് വരുത്തേണ്ടത് വിളിക്കുന്നയാളാണ്
പാഴ്‌സർ അവസ്ഥ ("PL_parser" et al) എന്നതിന്റെ ഉറവിടം പ്രതിഫലിപ്പിക്കുന്നതിന് ശരിയായി സജ്ജീകരിച്ചിരിക്കുന്നു
പാഴ്‌സ് ചെയ്യേണ്ട കോഡും പ്രസ്താവനയുടെ ലെക്സിക്കൽ സന്ദർഭവും.

പ്രസ്താവനയെ പ്രതിനിധീകരിക്കുന്ന ഓപ് ട്രീ തിരികെ നൽകി. എങ്കിൽ ഇതൊരു നൾ പോയിന്ററായിരിക്കാം
പ്രസ്താവന അസാധുവാണ്, ഉദാഹരണത്തിന് ഇത് യഥാർത്ഥത്തിൽ ഒരു സബ്റൂട്ടീൻ നിർവചനമാണെങ്കിൽ
(ഇതിന് കംപൈൽ-ടൈം പാർശ്വഫലങ്ങൾ ഉണ്ട്). ശൂന്യമല്ലെങ്കിൽ, അത് നേരിട്ട് ops ആയിരിക്കും
പ്രസ്‌താവന നടപ്പിലാക്കുന്നു, "newSTATEOP"-ലേക്ക് പോകാൻ അനുയോജ്യമാണ്. അത് ചെയ്യില്ല
സാധാരണയായി ഒരു "നെക്‌സ്റ്റ്‌സ്‌റ്റേറ്റ്" അല്ലെങ്കിൽ തത്തുല്യമായ ഓപ്‌സ് ഉൾപ്പെടുത്തുക (എയിൽ ഉൾച്ചേർത്തവ ഒഴികെ
വ്യാപ്തി പൂർണ്ണമായും പ്രസ്താവനയിൽ അടങ്ങിയിരിക്കുന്നു).

പാഴ്‌സിംഗിലോ സമാഹാരത്തിലോ ഒരു പിശക് സംഭവിക്കുകയാണെങ്കിൽ, മിക്ക കേസുകളിലും ഒരു സാധുവായ ഒപ് ട്രീ (മിക്കതും
സാധ്യത null) എന്തായാലും തിരികെ നൽകും. പിശക് പാർസർ അവസ്ഥയിൽ പ്രതിഫലിക്കുന്നു,
സാധാരണയായി പാഴ്‌സിംഗിന്റെ ഉയർന്ന തലത്തിൽ ഒരൊറ്റ ഒഴിവാക്കലിന് കാരണമാകുന്നു
സംഭവിച്ച എല്ലാ കംപൈലേഷൻ പിശകുകളും. എന്നിരുന്നാലും ചില കംപൈലേഷൻ പിശകുകൾ ഉണ്ടാകും
ഉടൻ ഒരു ഒഴിവാക്കൽ ഇടുക.

ദി ഫ്ലാഗുകൾ പരാമീറ്റർ ഭാവിയിലെ ഉപയോഗത്തിനായി നീക്കിവച്ചിരിക്കുന്നു, അത് എല്ലായ്പ്പോഴും പൂജ്യമായിരിക്കണം.

OP * parse_barestmt(U32 ഫ്ലാഗുകൾ)

പാർസ്_ബ്ലോക്ക്
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു പൂർണ്ണമായ പേൾ കോഡ് ബ്ലോക്ക് പാഴ്‌സ് ചെയ്യുക. ഇതിൽ ഒരു ഓപ്പണിംഗ് ബ്രേസ് അടങ്ങിയിരിക്കുന്നു, a
പ്രസ്താവനകളുടെ ക്രമം, ഒരു ക്ലോസിംഗ് ബ്രേസ്. ബ്ലോക്ക് ഒരു ലെക്സിക്കൽ രൂപീകരിക്കുന്നു
വ്യാപ്തി, അതിനാൽ "എന്റെ" വേരിയബിളുകളും വിവിധ കംപൈൽ-ടൈം ഇഫക്റ്റുകളും ഉള്ളിൽ അടങ്ങിയിരിക്കാം
അത്. ഡൈനാമിക് പാഴ്‌സർ നില ("PL_parser" എന്ന് ഉറപ്പാക്കേണ്ടത് കോളറുടെ ചുമതലയാണ്.
et al) പാഴ്‌സ് ചെയ്യേണ്ട കോഡിന്റെ ഉറവിടം പ്രതിഫലിപ്പിക്കുന്നതിന് ശരിയായി സജ്ജീകരിച്ചിരിക്കുന്നു
പ്രസ്താവനയുടെ ലെക്സിക്കൽ സന്ദർഭം.

കോഡ് ബ്ലോക്കിനെ പ്രതിനിധീകരിക്കുന്ന ഒപ് ട്രീ തിരികെ നൽകി. ഇത് എല്ലായ്പ്പോഴും ഒരു യഥാർത്ഥ ഓപ്പറേഷൻ ആണ്,
ഒരിക്കലും നൾ പോയിന്റർ അല്ല. ഇത് സാധാരണയായി "Nextstate" ഉൾപ്പെടെയുള്ള ഒരു "lineseq" ലിസ്റ്റായിരിക്കും
അല്ലെങ്കിൽ തത്തുല്യമായ ഓപ്‌സ്. ഏതെങ്കിലും തരത്തിലുള്ള റൺടൈം സ്കോപ്പ് നിർമ്മിക്കുന്നതിനുള്ള ഓപ്‌സുകളൊന്നും ഉൾപ്പെടുത്തിയിട്ടില്ല
അതൊരു ബ്ലോക്ക് ആയതിന്റെ ഗുണം.

പാഴ്‌സിംഗിലോ സമാഹാരത്തിലോ ഒരു പിശക് സംഭവിക്കുകയാണെങ്കിൽ, മിക്ക കേസുകളിലും ഒരു സാധുവായ ഒപ് ട്രീ (മിക്കതും
സാധ്യത null) എന്തായാലും തിരികെ നൽകും. പിശക് പാർസർ അവസ്ഥയിൽ പ്രതിഫലിക്കുന്നു,
സാധാരണയായി പാഴ്‌സിംഗിന്റെ ഉയർന്ന തലത്തിൽ ഒരൊറ്റ ഒഴിവാക്കലിന് കാരണമാകുന്നു
സംഭവിച്ച എല്ലാ കംപൈലേഷൻ പിശകുകളും. എന്നിരുന്നാലും ചില കംപൈലേഷൻ പിശകുകൾ ഉണ്ടാകും
ഉടൻ ഒരു ഒഴിവാക്കൽ ഇടുക.

ദി ഫ്ലാഗുകൾ പരാമീറ്റർ ഭാവിയിലെ ഉപയോഗത്തിനായി നീക്കിവച്ചിരിക്കുന്നു, അത് എല്ലായ്പ്പോഴും പൂജ്യമായിരിക്കണം.

OP * parse_block(U32 ഫ്ലാഗുകൾ)

parse_fullexpr
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു പൂർണ്ണമായ പേൾ എക്സ്പ്രഷൻ പാഴ്സ് ചെയ്യുക. ഇത് വ്യാകരണത്തിന്റെ പൂർണ്ണമായ പദപ്രയോഗം അനുവദിക്കുന്നു,
"അല്ലെങ്കിൽ" പോലുള്ള ഏറ്റവും കുറഞ്ഞ മുൻഗണനയുള്ള ഓപ്പറേറ്റർമാർ ഉൾപ്പെടെ. എക്സ്പ്രഷൻ ആയിരിക്കണം
ഒരു പദപ്രയോഗം സാധാരണ ആയിരിക്കുന്ന ഒരു ടോക്കൺ വഴി പിന്തുടരുന്നു (അങ്ങനെ അവസാനിപ്പിച്ചു).
അവസാനിപ്പിച്ചത്: ഫയലിന്റെ അവസാനം, ക്ലോസിംഗ് ബ്രാക്കറ്റിംഗ് ചിഹ്നനം, അർദ്ധവിരാമം അല്ലെങ്കിൽ ഇതിലൊന്ന്
ഒരു പോസ്റ്റ്ഫിക്സ് എക്സ്പ്രഷൻ-സ്റ്റേറ്റ്മെന്റ് മോഡിഫയറിനെ സൂചിപ്പിക്കുന്ന കീവേഡുകൾ. എങ്കിൽ ഫ്ലാഗുകൾ
"PARSE_OPTIONAL" ഉൾപ്പെടുന്നു, തുടർന്ന് എക്‌സ്‌പ്രഷൻ ഓപ്‌ഷണലാണ്, അല്ലാത്തപക്ഷം
നിർബന്ധമാണ്. ഡൈനാമിക് പാഴ്‌സർ അവസ്ഥ ഉറപ്പാക്കേണ്ടത് വിളിക്കുന്നയാളാണ്
("PL_parser" et al) കോഡിന്റെ ഉറവിടം പ്രതിഫലിപ്പിക്കുന്നതിന് ശരിയായി സജ്ജീകരിച്ചിരിക്കുന്നു
പാഴ്‌സ് ചെയ്‌തതും പദപ്രയോഗത്തിനുള്ള ലെക്സിക്കൽ സന്ദർഭവും.

പദപ്രയോഗത്തെ പ്രതിനിധീകരിക്കുന്ന ഓപ് ട്രീ തിരികെ നൽകി. ഒരു ഓപ്ഷണൽ എക്സ്പ്രഷൻ ആണെങ്കിൽ
ഇല്ലെങ്കിൽ, ഒരു നൾ പോയിന്റർ തിരികെ നൽകും, അല്ലാത്തപക്ഷം പോയിന്റർ അസാധുവായതായിരിക്കും.

പാഴ്‌സിംഗിലോ സമാഹാരത്തിലോ ഒരു പിശക് സംഭവിക്കുകയാണെങ്കിൽ, മിക്ക കേസുകളിലും ഒരു സാധുവായ ഓപ് ട്രീ ആയിരിക്കും
എന്തായാലും മടങ്ങി. പിശക് പാഴ്സർ അവസ്ഥയിൽ പ്രതിഫലിക്കുന്നു, സാധാരണയായി ഫലം
എല്ലാ കംപൈലേഷനും ഉൾക്കൊള്ളുന്ന പാഴ്‌സിംഗിന്റെ ഉയർന്ന തലത്തിൽ ഒരൊറ്റ ഒഴിവാക്കലിൽ
സംഭവിച്ച പിശകുകൾ. എന്നിരുന്നാലും ചില കംപൈലേഷൻ പിശകുകൾ ഒരു അപവാദം ഉണ്ടാക്കും
ഉടനെ.

OP * parse_fullexpr(U32 ഫ്ലാഗുകൾ)

parse_fullstmt
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു പൂർണ്ണമായ പേൾ പ്രസ്താവന പാഴ്‌സ് ചെയ്യുക. ഇതൊരു സാധാരണ അനിവാര്യമായ പ്രസ്താവനയായിരിക്കാം
അല്ലെങ്കിൽ കംപൈൽ-ടൈം ഇഫക്റ്റ് ഉള്ള ഒരു പ്രഖ്യാപനം, കൂടാതെ ഓപ്ഷണൽ ലേബലുകൾ ഉൾപ്പെട്ടേക്കാം.
ഡൈനാമിക് പാഴ്‌സർ നില ("PL_parser" et al) എന്ന് ഉറപ്പാക്കേണ്ടത് കോളറുടെ ചുമതലയാണ്.
പാഴ്‌സ് ചെയ്യേണ്ട കോഡിന്റെ ഉറവിടവും ലെക്സിക്കലും പ്രതിഫലിപ്പിക്കുന്നതിന് ശരിയായി സജ്ജീകരിച്ചിരിക്കുന്നു
പ്രസ്താവനയുടെ സന്ദർഭം.

പ്രസ്താവനയെ പ്രതിനിധീകരിക്കുന്ന ഓപ് ട്രീ തിരികെ നൽകി. എങ്കിൽ ഇതൊരു നൾ പോയിന്ററായിരിക്കാം
പ്രസ്താവന അസാധുവാണ്, ഉദാഹരണത്തിന് ഇത് യഥാർത്ഥത്തിൽ ഒരു സബ്റൂട്ടീൻ നിർവചനമാണെങ്കിൽ
(ഇതിന് കംപൈൽ-ടൈം പാർശ്വഫലങ്ങൾ ഉണ്ട്). ശൂന്യമല്ലെങ്കിൽ, അത് ഒരു ഫലമായിരിക്കും
"newSTATEOP" കോൾ, സാധാരണയായി ഒരു "നെക്‌സ്റ്റ്‌സ്‌റ്റേറ്റ്" അല്ലെങ്കിൽ തത്തുല്യമായ OP ഉൾപ്പെടെ.

പാഴ്‌സിംഗിലോ സമാഹാരത്തിലോ ഒരു പിശക് സംഭവിക്കുകയാണെങ്കിൽ, മിക്ക കേസുകളിലും ഒരു സാധുവായ ഒപ് ട്രീ (മിക്കതും
സാധ്യത null) എന്തായാലും തിരികെ നൽകും. പിശക് പാർസർ അവസ്ഥയിൽ പ്രതിഫലിക്കുന്നു,
സാധാരണയായി പാഴ്‌സിംഗിന്റെ ഉയർന്ന തലത്തിൽ ഒരൊറ്റ ഒഴിവാക്കലിന് കാരണമാകുന്നു
സംഭവിച്ച എല്ലാ കംപൈലേഷൻ പിശകുകളും. എന്നിരുന്നാലും ചില കംപൈലേഷൻ പിശകുകൾ ഉണ്ടാകും
ഉടൻ ഒരു ഒഴിവാക്കൽ ഇടുക.

ദി ഫ്ലാഗുകൾ പരാമീറ്റർ ഭാവിയിലെ ഉപയോഗത്തിനായി നീക്കിവച്ചിരിക്കുന്നു, അത് എല്ലായ്പ്പോഴും പൂജ്യമായിരിക്കണം.

OP * parse_fullstmt(U32 ഫ്ലാഗുകൾ)

parse_label
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു പേൾ പ്രിഫിക്‌സ് ചെയ്‌തേക്കാവുന്ന തരത്തിലുള്ള ഒരൊറ്റ ലേബൽ പാഴ്‌സ് ചെയ്യുക, ഒരുപക്ഷേ ഓപ്‌ഷണൽ
പ്രസ്താവന. ഡൈനാമിക് പാഴ്‌സർ അവസ്ഥ ഉറപ്പാക്കേണ്ടത് വിളിക്കുന്നയാളാണ്
("PL_parser" et al) കോഡിന്റെ ഉറവിടം പ്രതിഫലിപ്പിക്കുന്നതിന് ശരിയായി സജ്ജീകരിച്ചിരിക്കുന്നു
പാഴ്സ് ചെയ്തു. എങ്കിൽ ഫ്ലാഗുകൾ "PARSE_OPTIONAL" ഉൾപ്പെടുന്നു, തുടർന്ന് ലേബൽ ഓപ്ഷണലാണ്, അല്ലാത്തപക്ഷം
അത് നിർബന്ധമാണ്.

ലേബലിന്റെ പേര് പുതിയ സ്കെയിലറിന്റെ രൂപത്തിൽ തിരികെ നൽകുന്നു. ഒരു ഓപ്ഷണൽ ആണെങ്കിൽ
ലേബൽ ഇല്ല, ഒരു നൾ പോയിന്റർ തിരികെ നൽകി.

പാഴ്‌സിംഗിൽ ഒരു പിശക് സംഭവിക്കുകയാണെങ്കിൽ, അത് ലേബൽ നിർബന്ധമാണെങ്കിൽ മാത്രമേ സംഭവിക്കൂ, a
സാധുവായ ലേബൽ എന്തായാലും തിരികെ നൽകും. പാഴ്‌സർ അവസ്ഥയിൽ പിശക് പ്രതിഫലിക്കുന്നു,
സാധാരണയായി പാഴ്‌സിംഗിന്റെ ഉയർന്ന തലത്തിൽ ഒരൊറ്റ ഒഴിവാക്കലിന് കാരണമാകുന്നു
സംഭവിച്ച എല്ലാ കംപൈലേഷൻ പിശകുകളും.

SV * parse_label(U32 ഫ്ലാഗുകൾ)

parse_listexpr
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു പേൾ ലിസ്റ്റ് എക്സ്പ്രഷൻ പാഴ്സ് ചെയ്യുക. ഇതിൽ മുൻ‌ഗണനയുള്ള ഓപ്പറേറ്റർമാർ അടങ്ങിയിരിക്കാം
കോമ ഓപ്പറേറ്റർ. പദപ്രയോഗം ഒന്നുകിൽ പിന്തുടരേണ്ടതുണ്ട് (അങ്ങനെ അവസാനിപ്പിക്കണം).
"അല്ലെങ്കിൽ" പോലെയുള്ള ലോജിക് ഓപ്പറേറ്റർ മുഖേന അല്ലെങ്കിൽ എന്തെങ്കിലും
സാധാരണയായി അർദ്ധവിരാമം പോലുള്ള ഒരു പദപ്രയോഗം അവസാനിപ്പിക്കുക. എങ്കിൽ ഫ്ലാഗുകൾ ഉൾപ്പെടുന്നു
"PARSE_OPTIONAL" അപ്പോൾ എക്സ്പ്രഷൻ ഓപ്ഷണലാണ്, അല്ലാത്തപക്ഷം അത് നിർബന്ധമാണ്. അത്
ഡൈനാമിക് പാഴ്സർ നില ("PL_parser" et al) ആണെന്ന് ഉറപ്പാക്കാൻ വിളിക്കുന്നയാളാണ്
പാഴ്‌സ് ചെയ്യേണ്ട കോഡിന്റെ ഉറവിടവും ലെക്സിക്കലും പ്രതിഫലിപ്പിക്കുന്നതിന് ശരിയായി സജ്ജീകരിച്ചിരിക്കുന്നു
ആവിഷ്കാരത്തിനുള്ള സന്ദർഭം.

പദപ്രയോഗത്തെ പ്രതിനിധീകരിക്കുന്ന ഓപ് ട്രീ തിരികെ നൽകി. ഒരു ഓപ്ഷണൽ എക്സ്പ്രഷൻ ആണെങ്കിൽ
ഇല്ലെങ്കിൽ, ഒരു നൾ പോയിന്റർ തിരികെ നൽകും, അല്ലാത്തപക്ഷം പോയിന്റർ അസാധുവായതായിരിക്കും.

പാഴ്‌സിംഗിലോ സമാഹാരത്തിലോ ഒരു പിശക് സംഭവിക്കുകയാണെങ്കിൽ, മിക്ക കേസുകളിലും ഒരു സാധുവായ ഓപ് ട്രീ ആയിരിക്കും
എന്തായാലും മടങ്ങി. പിശക് പാഴ്സർ അവസ്ഥയിൽ പ്രതിഫലിക്കുന്നു, സാധാരണയായി ഫലം
എല്ലാ കംപൈലേഷനും ഉൾക്കൊള്ളുന്ന പാഴ്‌സിംഗിന്റെ ഉയർന്ന തലത്തിൽ ഒരൊറ്റ ഒഴിവാക്കലിൽ
സംഭവിച്ച പിശകുകൾ. എന്നിരുന്നാലും ചില കംപൈലേഷൻ പിശകുകൾ ഒരു അപവാദം ഉണ്ടാക്കും
ഉടനെ.

OP * parse_listexpr(U32 ഫ്ലാഗുകൾ)

parse_stmtseq
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

പൂജ്യമോ അതിലധികമോ പേൾ പ്രസ്താവനകളുടെ ഒരു ശ്രേണി പാഴ്‌സ് ചെയ്യുക. ഇവ സാധാരണ നിർബന്ധമായിരിക്കാം
ഓപ്ഷണൽ ലേബലുകൾ ഉൾപ്പെടെയുള്ള പ്രസ്താവനകൾ, അല്ലെങ്കിൽ കംപൈൽ-ടൈം ഉള്ള പ്രഖ്യാപനങ്ങൾ
പ്രഭാവം, അല്ലെങ്കിൽ അതിന്റെ ഏതെങ്കിലും മിശ്രിതം. ഒരു ക്ലോസിംഗ് ബ്രേസ് ചെയ്യുമ്പോൾ സ്റ്റേറ്റ്മെന്റ് സീക്വൻസ് അവസാനിക്കുന്നു
അല്ലെങ്കിൽ എൻഡ്-ഓഫ്-ഫയൽ ഒരു പുതിയ പ്രസ്താവനയ്ക്ക് സാധുതയുള്ള ഒരു സ്ഥലത്ത് കണ്ടുമുട്ടുന്നു
തുടങ്ങി. ഡൈനാമിക് പാഴ്‌സർ അവസ്ഥ ഉറപ്പാക്കേണ്ടത് വിളിക്കുന്നയാളാണ്
("PL_parser" et al) കോഡിന്റെ ഉറവിടം പ്രതിഫലിപ്പിക്കുന്നതിന് ശരിയായി സജ്ജീകരിച്ചിരിക്കുന്നു
പാഴ്‌സ് ചെയ്‌തതും പ്രസ്താവനകളുടെ ലെക്സിക്കൽ സന്ദർഭവും.

പ്രസ്താവന ക്രമത്തെ പ്രതിനിധീകരിക്കുന്ന ഓപ് ട്രീ തിരികെ നൽകി. ഇതൊരു ശൂന്യമായിരിക്കാം
പ്രസ്‌താവനകളെല്ലാം അസാധുവാണെങ്കിൽ സൂചിക, ഉദാഹരണത്തിന് പ്രസ്താവനകൾ ഇല്ലെങ്കിൽ
അല്ലെങ്കിൽ സബ്റൂട്ടീൻ നിർവചനങ്ങൾ മാത്രമേ ഉണ്ടായിരുന്നുള്ളൂവെങ്കിൽ (അവയ്ക്ക് കംപൈൽ-ടൈം സൈഡ് ഉണ്ട്
ഇഫക്റ്റുകൾ). അസാധുവാണെങ്കിൽ, അത് ഒരു "lineseq" ലിസ്റ്റ് ആയിരിക്കും, സാധാരണയായി ഇതിൽ ഉൾപ്പെടുന്നു
"Nextstate" അല്ലെങ്കിൽ തത്തുല്യമായ ഓപ്‌സ്.

പാഴ്‌സിംഗിലോ സമാഹാരത്തിലോ ഒരു പിശക് സംഭവിക്കുകയാണെങ്കിൽ, മിക്ക കേസുകളിലും ഒരു സാധുവായ ഓപ് ട്രീ ആയിരിക്കും
എന്തായാലും മടങ്ങി. പിശക് പാഴ്സർ അവസ്ഥയിൽ പ്രതിഫലിക്കുന്നു, സാധാരണയായി ഫലം
എല്ലാ കംപൈലേഷനും ഉൾക്കൊള്ളുന്ന പാഴ്‌സിംഗിന്റെ ഉയർന്ന തലത്തിൽ ഒരൊറ്റ ഒഴിവാക്കലിൽ
സംഭവിച്ച പിശകുകൾ. എന്നിരുന്നാലും ചില കംപൈലേഷൻ പിശകുകൾ ഒരു അപവാദം ഉണ്ടാക്കും
ഉടനെ.

ദി ഫ്ലാഗുകൾ പരാമീറ്റർ ഭാവിയിലെ ഉപയോഗത്തിനായി നീക്കിവച്ചിരിക്കുന്നു, അത് എല്ലായ്പ്പോഴും പൂജ്യമായിരിക്കണം.

OP * parse_stmtseq(U32 ഫ്ലാഗുകൾ)

parse_termexpr
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു പേൾ പദപ്രയോഗം പാഴ്‌സ് ചെയ്യുക. ഇതിൽ മുൻ‌ഗണനയുള്ള ഓപ്പറേറ്റർമാർ അടങ്ങിയിരിക്കാം
അസൈൻമെന്റ് ഓപ്പറേറ്റർമാർ. പദപ്രയോഗം പിന്തുടരേണ്ടതുണ്ട് (അങ്ങനെ അവസാനിപ്പിക്കുക)
ഒന്നുകിൽ കോമ അല്ലെങ്കിൽ ലോവർ-പ്രിസിഡൻസ് ഓപ്പറേറ്റർ അല്ലെങ്കിൽ സാധാരണ ചെയ്യുന്ന എന്തെങ്കിലും
അർദ്ധവിരാമം പോലുള്ള ഒരു പദപ്രയോഗം അവസാനിപ്പിക്കുക. എങ്കിൽ ഫ്ലാഗുകൾ "PARSE_OPTIONAL" ഉൾപ്പെടുന്നു
അപ്പോൾ എക്സ്പ്രഷൻ ഓപ്ഷണൽ ആണ്, അല്ലാത്തപക്ഷം അത് നിർബന്ധമാണ്. വരെ ആണ്
ഡൈനാമിക് പാർസർ അവസ്ഥ ("PL_parser" et al) ശരിയാണെന്ന് ഉറപ്പാക്കാൻ വിളിക്കുന്നയാൾ
പാഴ്‌സ് ചെയ്യേണ്ട കോഡിന്റെ ഉറവിടവും അതിനുള്ള ലെക്സിക്കൽ സന്ദർഭവും പ്രതിഫലിപ്പിക്കുന്ന തരത്തിൽ സജ്ജമാക്കി
എക്സ്പ്രഷൻ.

പദപ്രയോഗത്തെ പ്രതിനിധീകരിക്കുന്ന ഓപ് ട്രീ തിരികെ നൽകി. ഒരു ഓപ്ഷണൽ എക്സ്പ്രഷൻ ആണെങ്കിൽ
ഇല്ലെങ്കിൽ, ഒരു നൾ പോയിന്റർ തിരികെ നൽകും, അല്ലാത്തപക്ഷം പോയിന്റർ അസാധുവായതായിരിക്കും.

പാഴ്‌സിംഗിലോ സമാഹാരത്തിലോ ഒരു പിശക് സംഭവിക്കുകയാണെങ്കിൽ, മിക്ക കേസുകളിലും ഒരു സാധുവായ ഓപ് ട്രീ ആയിരിക്കും
എന്തായാലും മടങ്ങി. പിശക് പാഴ്സർ അവസ്ഥയിൽ പ്രതിഫലിക്കുന്നു, സാധാരണയായി ഫലം
എല്ലാ കംപൈലേഷനും ഉൾക്കൊള്ളുന്ന പാഴ്‌സിംഗിന്റെ ഉയർന്ന തലത്തിൽ ഒരൊറ്റ ഒഴിവാക്കലിൽ
സംഭവിച്ച പിശകുകൾ. എന്നിരുന്നാലും ചില കംപൈലേഷൻ പിശകുകൾ ഒരു അപവാദം ഉണ്ടാക്കും
ഉടനെ.

OP * parse_termexpr(U32 ഫ്ലാഗുകൾ)

PL_parser
നിലവിലെ പാഴ്‌സിംഗ് പ്രവർത്തനത്തിന്റെ അവസ്ഥ ഉൾക്കൊള്ളുന്ന ഒരു ഘടനയിലേക്കുള്ള പോയിന്റർ
പുരോഗതിയിൽ. കൂടാതെ നെസ്റ്റഡ് പാഴ്‌സ് ചെയ്യുന്നതിനായി പോയിന്റർ പ്രാദേശികമായി മാറ്റാവുന്നതാണ്
ഒരു ബാഹ്യ പാഴ്‌സിന്റെ അവസ്ഥയിൽ ഇടപെടുന്നു. "PL_parser"-ന്റെ വ്യക്തിഗത അംഗങ്ങൾ
അവരുടെ സ്വന്തം ഡോക്യുമെന്റേഷൻ ഉണ്ട്.

PL_parser->bufend
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

നിലവിൽ ലെക്‌സ് ചെയ്‌തിരിക്കുന്ന ടെക്‌സ്‌റ്റിന്റെ അറ്റത്തേക്ക് ഡയറക്‌റ്റ് പോയിന്റർ, അവസാനം
ലെക്സർ ബഫർ. ഇത് "SvPVX(PL_parser->linestr) + ന് തുല്യമാണ്
SvCUR(PL_parser->linestr)". ഒരു "NUL" പ്രതീകം (പൂജ്യം ഒക്ടറ്റ്) എപ്പോഴും സ്ഥിതി ചെയ്യുന്നത്
ബഫറിന്റെ അവസാനം, ബഫറിന്റെ ഉള്ളടക്കത്തിന്റെ ഭാഗമായി കണക്കാക്കില്ല.

PL_parser->bufptr
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ലെക്‌സർ ബഫറിനുള്ളിലെ ലെക്‌സിംഗിന്റെ നിലവിലെ സ്ഥാനത്തേക്ക് പോയിന്റുകൾ. കഥാപാത്രങ്ങൾ
ഈ ഘട്ടത്തിൽ പരിധി നിശ്ചയിച്ചിട്ടുള്ള പരിധിക്കുള്ളിൽ സ്വതന്ത്രമായി പരിശോധിക്കാവുന്നതാണ്
"SvPVX("PL_parser->linestr")", "PL_parser->bufend". ബഫറിന്റെ ഒക്റ്ററ്റുകൾ
UTF-8 അല്ലെങ്കിൽ ലാറ്റിൻ-1 ആയി വ്യാഖ്യാനിക്കാൻ ഉദ്ദേശിച്ചേക്കാം
"lex_bufutf8".

ലെക്സിംഗ് കോഡ് (പേൾ കോറിലായാലും ഇല്ലെങ്കിലും) ഈ പോയിന്ററിനെ മറികടക്കുന്നു
അത് ഉപയോഗിക്കുന്ന പ്രതീകങ്ങൾ. ഇത് കുറച്ച് ബുക്ക് കീപ്പിംഗ് നടത്തുമെന്നും പ്രതീക്ഷിക്കുന്നു
ഒരു പുതിയ ലൈൻ പ്രതീകം ഉപയോഗിക്കുമ്പോഴെല്ലാം. ഈ പ്രസ്ഥാനം കൂടുതൽ സൗകര്യപ്രദമായിരിക്കും
ന്യൂലൈനുകൾ ഉചിതമായി കൈകാര്യം ചെയ്യുന്ന "lex_read_to" എന്ന ഫംഗ്‌ഷൻ നടപ്പിലാക്കുന്നു.

ചെറുതായി ഉപയോഗിച്ചുകൊണ്ട് ബഫറിന്റെ ഒക്ടറ്റുകളുടെ വ്യാഖ്യാനം അമൂർത്തമാക്കാവുന്നതാണ്
ഉയർന്ന തലത്തിലുള്ള പ്രവർത്തനങ്ങൾ "lex_peek_unichar", "lex_read_unichar" എന്നിവ.

PL_parser->linestart
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ലെക്‌സർ ബഫറിനുള്ളിലെ കറന്റ് ലൈനിന്റെ ആരംഭത്തിലേക്കുള്ള പോയിന്റുകൾ. ഇത് ഉപയോഗപ്രദമാണ്
ഏത് കോളത്തിലാണ് ഒരു പിശക് സംഭവിച്ചതെന്ന് സൂചിപ്പിക്കാൻ, മറ്റൊന്നുമല്ല. ഇതായിരിക്കണം
ഒരു പുതിയ ലൈൻ ഉപയോഗിക്കുന്ന ഏതെങ്കിലും ലെക്സിംഗ് കോഡ് ഉപയോഗിച്ച് അപ്ഡേറ്റ് ചെയ്തു; "lex_read_to" എന്ന ഫംഗ്‌ഷൻ
ഈ വിശദാംശം കൈകാര്യം ചെയ്യുന്നു.

PL_parser->linestr
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

നിലവിൽ വാചകത്തിന്റെ പരിഗണനയിലുള്ള ഭാഗം അടങ്ങുന്ന ബഫർ സ്കെയിലർ
നിലവിൽ lexed ചെയ്യുന്നു. ഇത് എല്ലായ്പ്പോഴും ഒരു പ്ലെയിൻ സ്ട്രിംഗ് സ്കെയിലർ ആണ് (ഇതിന് "SvPOK" ആണ്
സത്യം). ഇത് സാധാരണ സ്കെയിലർ മാർഗങ്ങളിലൂടെ ഒരു സ്കെയിലറായി ഉപയോഗിക്കാൻ ഉദ്ദേശിച്ചുള്ളതല്ല; പകരം
ചുവടെ വിവരിച്ചിരിക്കുന്ന പോയിന്റർ വേരിയബിളുകൾ ഉപയോഗിച്ച് ബഫർ നേരിട്ട് റഫർ ചെയ്യുക.

"PL_parser->linestr" എന്നതിലെ കാര്യങ്ങൾക്കുള്ള വിവിധ "char*" പോയിന്ററുകൾ lexer പരിപാലിക്കുന്നു.
ബഫർ. "PL_parser->linestr" എപ്പോഴെങ്കിലും വീണ്ടും അനുവദിച്ചിട്ടുണ്ടെങ്കിൽ, ഈ എല്ലാ പോയിന്ററുകളും നിർബന്ധമാണ്
അപ്ഡേറ്റ് ചെയ്യപ്പെടും. ഇത് സ്വമേധയാ ചെയ്യാൻ ശ്രമിക്കരുത്, പകരം "lex_grow_linestr" ഉപയോഗിക്കുക
നിങ്ങൾക്ക് ബഫർ വീണ്ടും ലൊക്കേറ്റ് ചെയ്യണമെങ്കിൽ.

ബഫറിലെ ടെക്സ്റ്റ് ചങ്കിന്റെ ഉള്ളടക്കം സാധാരണയായി ഒരു പൂർണ്ണമായ വരിയാണ്
ഇൻപുട്ടിന്റെ, ഒരു പുതിയ ലൈൻ ടെർമിനേറ്റർ ഉൾപ്പെടെ, പക്ഷേ സാഹചര്യങ്ങളുണ്ട്
അത് മറിച്ചാണ്. ബഫറിന്റെ ഒക്ടറ്റുകളെ ഇപ്രകാരം വ്യാഖ്യാനിക്കാൻ ഉദ്ദേശിച്ചിരിക്കാം
ഒന്നുകിൽ UTF-8 അല്ലെങ്കിൽ ലാറ്റിൻ-1. ഫംഗ്‌ഷൻ "lex_bufutf8" ഏതാണെന്ന് നിങ്ങളോട് പറയുന്നു. ഉപയോഗിക്കരുത്
ഈ സ്കെയിലറിലെ "SvUTF8" ഫ്ലാഗ്, അതിനോട് വിയോജിക്കാം.

ബഫറിന്റെ നേരിട്ടുള്ള പരിശോധനയ്ക്കായി, "PL_parser->bufend" എന്ന വേരിയബിൾ ചൂണ്ടിക്കാണിക്കുന്നു
ബഫറിന്റെ അവസാനം. നിലവിലെ ലെക്സിംഗ് സ്ഥാനം ചൂണ്ടിക്കാണിക്കുന്നു
"PL_parser->bufptr". ഈ പോയിന്ററുകളുടെ നേരിട്ടുള്ള ഉപയോഗം സാധാരണയായി അഭികാമ്യമാണ്
സാധാരണ സ്കെയിലർ മാർഗങ്ങളിലൂടെ സ്കെയിലറിന്റെ പരിശോധന.

പ്രാദേശികമായി ബന്ധപ്പെട്ടത് ഫംഗ്ഷനുകളും ഒപ്പം മാക്രോകൾ

DECLARATION_FOR_LC_NUMERIC_MANIPULATION
ഈ മാക്രോ ഒരു പ്രസ്താവനയായി ഉപയോഗിക്കണം. ഇത് ഒരു സ്വകാര്യ വേരിയബിൾ പ്രഖ്യാപിക്കുന്നു (ആരുടെ
പേര് ഒരു അടിവരയോടുകൂടിയാണ് ആരംഭിക്കുന്നത്) ഇതിലെ മറ്റ് മാക്രോകൾക്ക് ഇത് ആവശ്യമാണ്
വിഭാഗം. ഇത് ശരിയായി ഉൾപ്പെടുത്തുന്നതിൽ പരാജയപ്പെടുന്നത് ഒരു വാക്യഘടന പിശകിലേക്ക് നയിക്കും. വേണ്ടി
C89 C കംപൈലറുകളുമായുള്ള അനുയോജ്യത ഏതെങ്കിലും ഒരു ബ്ലോക്കിൽ സ്ഥാപിക്കണം
എക്സിക്യൂട്ടബിൾ പ്രസ്താവനകൾ.

DECLARATION_FOR_LC_NUMERIC_MANIPULATION അസാധുവാണ്

RESTORE_LC_NUMERIC
മാക്രോകളിൽ ഒന്നിനോട് ചേർന്നാണ് ഇത് ഉപയോഗിക്കുന്നത്
"STORE_LC_NUMERIC_SET_TO_NEEDED" കൂടാതെ "STORE_LC_NUMERIC_FORCE_TO_UNDERLYING"

"LC_NUMERIC" അവസ്ഥ ശരിയായി പുനഃസ്ഥാപിക്കാൻ.

പ്രഖ്യാപിക്കാൻ "DECLARATION_FOR_LC_NUMERIC_MANIPULATION" എന്നതിലേക്ക് ഒരു കോൾ ചെയ്തിരിക്കണം
കംപൈൽ സമയത്ത് ഈ മാക്രോയും രണ്ട് "സ്റ്റോർ" ഉം ഉപയോഗിക്കുന്ന ഒരു സ്വകാര്യ വേരിയബിൾ.
ഈ മാക്രോയെ ഒരൊറ്റ പ്രസ്താവനയായി വിളിക്കണം, ഒരു പദപ്രയോഗമല്ല, മറിച്ച് ഒരു
ശൂന്യമായ ആർഗ്യുമെന്റ് ലിസ്റ്റ്, ഇതുപോലെ:

{
DECLARATION_FOR_LC_NUMERIC_MANIPULATION;
...
RESTORE_LC_NUMERIC();
...
}

അസാധുവാണ് RESTORE_LC_NUMERIC()

STORE_LC_NUMERIC_FORCE_TO_UNDERLYING
"LC_NUMERIC" ലൊക്കേൽ-അവേർ ആയ XS കോഡാണ് ഇത് ഉപയോഗിക്കുന്നത്
"LC_NUMERIC" എന്ന വിഭാഗത്തിന്, നിലവിലെ അണ്ടർലൈയിംഗ് ലൊക്കേൽ ആണെന്ന് perl കരുതുന്നു.
(അടിസ്ഥാനത്തിലുള്ള ലൊക്കേൽ എന്താണെന്നതിനെക്കുറിച്ച് perl വ്യാഖ്യാതാവ് തെറ്റായിരിക്കാം
ചില C അല്ലെങ്കിൽ XS കോഡ് C ലൈബ്രറി ഫംഗ്‌ഷൻ എന്ന് വിളിച്ചിട്ടുണ്ടെങ്കിൽ സെറ്റ് ലോക്കേൽ(3) അതിന്റെ പിന്നിൽ
തിരികെ; ഈ മാക്രോയിലേക്ക് വിളിക്കുന്നതിന് മുമ്പ് "sync_locale" എന്ന് വിളിക്കുന്നത് perl-ന്റെ റെക്കോർഡുകൾ അപ്ഡേറ്റ് ചെയ്യും.)

പ്രഖ്യാപിക്കാൻ "DECLARATION_FOR_LC_NUMERIC_MANIPULATION" എന്നതിലേക്ക് ഒരു കോൾ ചെയ്തിരിക്കണം
കംപൈൽ സമയത്ത് ഈ മാക്രോ ഉപയോഗിക്കുന്ന ഒരു സ്വകാര്യ വേരിയബിൾ. ഈ മാക്രോ ആയിരിക്കണം
ഒരു പദപ്രയോഗമായിട്ടല്ല, ഒരു ശൂന്യമായ ആർഗ്യുമെന്റ് ലിസ്‌റ്റോടെയാണ് വിളിക്കുന്നത്,
ഇതുപോലെ:

{
DECLARATION_FOR_LC_NUMERIC_MANIPULATION;
...
STORE_LC_NUMERIC_FORCE_TO_UNDERLYING();
...
RESTORE_LC_NUMERIC();
...
}

നിലവിലെ പ്രാദേശിക അവസ്ഥ സംരക്ഷിക്കാൻ സ്വകാര്യ വേരിയബിൾ ഉപയോഗിക്കുന്നു, അങ്ങനെ
"RESTORE_LC_NUMERIC" എന്നതിലേക്കുള്ള ആവശ്യമായ പൊരുത്തമുള്ള കോളിന് അത് പുനഃസ്ഥാപിക്കാൻ കഴിയും.

അസാധുവാണ് STORE_LC_NUMERIC_FORCE_TO_UNDERLYING()

STORE_LC_NUMERIC_SET_TO_NEEDED
"LC_NUMERIC" ലൊക്കേൽ-അവേർ ആയ XS അല്ലെങ്കിൽ C കോഡ് പൊതിയാൻ ഇത് ഉപയോഗിക്കുന്നു.
ഈ ലൊക്കേൽ വിഭാഗം പൊതുവെ പിന്നാക്കക്കാർക്കായി പേൾ C ലൊക്കേലിലേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു
അനുയോജ്യത, കൂടാതെ ഫ്ലോട്ടിംഗ് പോയിന്റ് മൂല്യങ്ങൾ വായിക്കുന്ന മിക്ക XS കോഡുകളും നേരിടാൻ കഴിയും
ദശാംശ റാഡിക്സ് പ്രതീകം ഒരു ഡോട്ടായി മാത്രം.

നിലവിലെ "LC_NUMERIC" നില ശരിയായി സജ്ജീകരിച്ചിട്ടുണ്ടെന്ന് ഈ മാക്രോ ഉറപ്പാക്കുന്നു, അറിഞ്ഞിരിക്കുക
Perl പ്രോഗ്രാമിൽ നിന്നുള്ള XS അല്ലെങ്കിൽ C കോഡിലേക്കുള്ള കോൾ അതിനുള്ളിൽ നിന്നാണെങ്കിൽ പ്രാദേശികമായി
ഒരു "ഉപയോഗ ലൊക്കേലിന്റെ" വ്യാപ്തി; അല്ലെങ്കിൽ പുറത്ത് നിന്നുള്ള കോൾ ആണെങ്കിൽ ലൊക്കേൽ അവഗണിക്കുക
അത്തരം വ്യാപ്തി.

ഈ മാക്രോ C അല്ലെങ്കിൽ XS കോഡ് പൊതിയുന്നതിന്റെ തുടക്കമാണ്; പൊതിയുന്ന അവസാനം ചെയ്യുന്നത്
പ്രവർത്തനത്തിന് ശേഷം "RESTORE_LC_NUMERIC" മാക്രോയിലേക്ക് വിളിക്കുന്നു. അല്ലെങ്കിൽ സംസ്ഥാനം
മറ്റ് XS കോഡിനെ പ്രതികൂലമായി ബാധിക്കും.

പ്രഖ്യാപിക്കാൻ "DECLARATION_FOR_LC_NUMERIC_MANIPULATION" എന്നതിലേക്ക് ഒരു കോൾ ചെയ്തിരിക്കണം
കംപൈൽ സമയത്ത് ഈ മാക്രോ ഉപയോഗിക്കുന്ന ഒരു സ്വകാര്യ വേരിയബിൾ. ഈ മാക്രോ ആയിരിക്കണം
ഒരു പദപ്രയോഗമായിട്ടല്ല, ഒരു ശൂന്യമായ ആർഗ്യുമെന്റ് ലിസ്‌റ്റോടെയാണ് വിളിക്കുന്നത്,
ഇതുപോലെ:

{
DECLARATION_FOR_LC_NUMERIC_MANIPULATION;
...
STORE_LC_NUMERIC_SET_TO_NEEDED();
...
RESTORE_LC_NUMERIC();
...
}

അസാധുവാണ് STORE_LC_NUMERIC_SET_TO_NEEDED()

sync_locale
XS കോഡ് ഉപയോഗിച്ച് പ്രോഗ്രാമിന്റെ ലൊക്കേൽ മാറ്റുന്നത് ഒഴിവാക്കണം. എന്നിരുന്നാലും, ഉറപ്പാണ്
XS-ൽ നിന്ന് വിളിക്കുന്ന "Gtk" പോലുള്ള നോൺ-പേൾ ലൈബ്രറികൾ അങ്ങനെ ചെയ്യുന്നു. ഇത് സംഭവിക്കുമ്പോൾ, പേൾ
ഭാഷ മാറിയെന്ന് പറയേണ്ടതുണ്ട്. അതിനു മുമ്പ്, ഈ ഫംഗ്ഷൻ ഉപയോഗിക്കുക
പേളിലേക്ക് മടങ്ങുന്നു.

ശൂന്യമായ sync_locale()

മാന്ത്രികം പ്രവർത്തനങ്ങൾ

mg_clear
SV പ്രതിനിധീകരിക്കുന്ന മാന്ത്രികമായ എന്തെങ്കിലും മായ്‌ക്കുക. "sv_magic" കാണുക.

int mg_clear(SV* sv)

mg_copy ഒരു എസ്‌വിയിൽ നിന്ന് മറ്റൊന്നിലേക്ക് മാജിക് പകർത്തുന്നു. "sv_magic" കാണുക.

int mg_copy(SV *sv, SV *nsv, കോൺസ്റ്റ് ചാർ *കീ,
I32 klen)

mg_find SV-യുമായി പൊരുത്തപ്പെടുന്ന തരത്തിനായുള്ള മാജിക് പോയിന്റർ കണ്ടെത്തുന്നു. "sv_magic" കാണുക.

MAGIC* mg_find(const SV* sv, int തരം)

mg_findext
"SV" എന്നതിനായി നൽകിയിരിക്കുന്ന "vtbl" ഉപയോഗിച്ച് "ടൈപ്പ്" എന്ന മാജിക് പോയിന്റർ കണ്ടെത്തുന്നു. കാണുക
"sv_magicext".

MAGIC* mg_findext(const SV* sv, int തരം,
const MGVTBL *vtbl)

mg_free SV ഉപയോഗിക്കുന്ന ഏതെങ്കിലും മാജിക് സ്റ്റോറേജ് സൗജന്യം. "sv_magic" കാണുക.

int mg_free(SV* sv)

mg_free_type
ഏതെങ്കിലും തരത്തിലുള്ള മാന്ത്രികത നീക്കം ചെയ്യുക എങ്ങനെ എസ്.വിയിൽ നിന്ന് sv. "sv_magic" കാണുക.

void mg_free_type(SV *sv, int how)

mg_get SV-യിൽ നിന്ന് ഒരു മൂല്യം വീണ്ടെടുക്കുന്നതിന് മുമ്പ് മാജിക് ചെയ്യുക. SV-യുടെ തരം >= ആയിരിക്കണം
SVt_PVMG. "sv_magic" കാണുക.

int mg_get(SV* sv)

mg_length
ഒഴിവാക്കി! പേളിന്റെ ഭാവി റിലീസിൽ നിന്ന് ഈ ഫംഗ്‌ഷൻ നീക്കം ചെയ്യാൻ പദ്ധതിയിട്ടിട്ടുണ്ട്.
പുതിയ കോഡിനായി ഇത് ഉപയോഗിക്കരുത്; നിലവിലുള്ള കോഡിൽ നിന്ന് അത് നീക്കം ചെയ്യുക.

SV-യുടെ ദൈർഘ്യം ബൈറ്റുകളിൽ റിപ്പോർട്ടുചെയ്യുന്നു, ലഭ്യമാണെങ്കിൽ ദൈർഘ്യം മാജിക് എന്ന് വിളിക്കുന്നു, പക്ഷേ അങ്ങനെ ചെയ്യുന്നു
sv-ൽ UTF8 ഫ്ലാഗ് സജ്ജീകരിക്കരുത്. ഇല്ലെങ്കിൽ അത് വീണ്ടും 'ഗറ്റ്' മാജിക്കിലേക്ക് വീഴും
'ദൈർഘ്യം' മാജിക്, പക്ഷേ അതിനെ 'ഗെറ്റ്' മാജിക് എന്ന് വിളിച്ചോ എന്നതിന് സൂചനയില്ല. അത്
sv ഒരു PVMG അല്ലെങ്കിൽ ഉയർന്നതാണെന്ന് അനുമാനിക്കുന്നു. ഉപയോഗിക്കുക sv_len() പകരം.

U32 mg_length(SV* sv)

mg_മാന്ത്രിക
ഒരു എസ്വിയുടെ മാന്ത്രിക നില ഓണാക്കുന്നു. "sv_magic" കാണുക.

ശൂന്യം mg_magical(SV* sv)

mg_set SV-ക്ക് ഒരു മൂല്യം നൽകിയ ശേഷം മാജിക് ചെയ്യുക. "sv_magic" കാണുക.

int mg_set(SV* sv)

SvGETMAGIC
ഒരു എസ്‌വിയിൽ 'ഗെറ്റ്' മാജിക് ഉണ്ടെങ്കിൽ "mg_get" അഭ്യർത്ഥിക്കുന്നു. ഉദാഹരണത്തിന്, ഇത് വിളിക്കും
ഒരു ടൈഡ് വേരിയബിളിൽ "FETCH". ഈ മാക്രോ അതിന്റെ വാദം ഒന്നിലധികം തവണ വിലയിരുത്തുന്നു.

അസാധുവായ SvGETMAGIC(SV* sv)

അനുയോജ്യമായ ഒരു മൊഡ്യൂൾ ഉണ്ടെങ്കിൽ sv-യിൽ ഒരു മ്യൂച്വൽ ഒഴിവാക്കൽ ലോക്ക് ലഭിക്കുന്നതിന് SvLOCK ക്രമീകരിക്കുന്നു
ലോഡ് ചെയ്തു.

അസാധുവായ SvLOCK(SV* sv)

SvSETMAGIC
ഒരു എസ്‌വിയിൽ 'സെറ്റ്' മാജിക് ഉണ്ടെങ്കിൽ "mg_set" അഭ്യർത്ഥിക്കുന്നു. ശേഷം ഇത് ആവശ്യമാണ്
$| പോലെയുള്ള ഒരു മാന്ത്രിക വേരിയബിളാണെങ്കിൽ, ഒരു സ്കെയിലർ പരിഷ്ക്കരിക്കുന്നു അല്ലെങ്കിൽ ഒരു ടൈഡ് വേരിയബിൾ
(ഇത് "സ്റ്റോർ" എന്ന് വിളിക്കുന്നു). ഈ മാക്രോ അതിന്റെ വാദം ഒന്നിലധികം തവണ വിലയിരുത്തുന്നു.

അസാധുവായ SvSETMAGIC(SV* sv)

SvSetMagicSV
"SvSetSV" പോലെ, എന്നാൽ പിന്നീട് ആവശ്യമായ ഏതെങ്കിലും സെറ്റ് മാജിക് ചെയ്യുന്നു.

അസാധുവായ SvSetMagicSV(SV* dsv, SV* ssv)

SvSetMagicSV_nosteal
"SvSetSV_nosteal" പോലെ, എന്നാൽ പിന്നീട് ആവശ്യമായ ഏതെങ്കിലും സെറ്റ് മാജിക് ചെയ്യുന്നു.

അസാധുവായ SvSetMagicSV_nosteal(SV* dsv, SV* ssv)

SvSetSV, dsv ssv പോലെയല്ലെങ്കിൽ "sv_setsv" എന്ന് വിളിക്കുന്നു. കൂടുതൽ വാദങ്ങൾ വിലയിരുത്താം
ഒരിക്കല്. ലക്ഷ്യസ്ഥാനമായ എസ്‌വിയിൽ 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നില്ല.

അസാധുവായ SvSetSV(SV* dsv, SV* ssv)

SvSetSV_nosteal
dsv ssv അല്ലെങ്കിൽ "sv_setsv"-ന്റെ ഒരു നോൺ-ഡിസ്ട്രക്റ്റീവ് പതിപ്പിനെ വിളിക്കുന്നു. മെയ്
ഒന്നിലധികം തവണ വാദങ്ങൾ വിലയിരുത്തുക.

അസാധുവായ SvSetSV_nosteal(SV* dsv, SV* ssv)

അനുയോജ്യമായ മൊഡ്യൂൾ ലോഡ് ചെയ്തിട്ടുണ്ടെങ്കിൽ, ത്രെഡുകൾക്കിടയിൽ sv പങ്കിടുന്നതിന് SvSHARE ക്രമീകരിക്കുന്നു.

അസാധുവായ SvSHARE(SV* sv)

SvUNLOCK
അനുയോജ്യമായ മൊഡ്യൂൾ ലോഡ് ചെയ്തിട്ടുണ്ടെങ്കിൽ sv-യിൽ ഒരു മ്യൂച്വൽ ഒഴിവാക്കൽ ലോക്ക് റിലീസ് ചെയ്യുന്നു.

അസാധുവായ SvUNLOCK(SV* sv)

മെമ്മറി മാനേജ്മെന്റ്

C "memcpy" ഫംഗ്‌ഷനിലേക്ക് XSUB-റൈറ്ററിന്റെ ഇന്റർഫേസ് പകർത്തുക. "src" ആണ് ഉറവിടം,
"dest" എന്നത് ലക്ഷ്യസ്ഥാനമാണ്, "നൈറ്റങ്ങൾ" എന്നത് ഇനങ്ങളുടെ എണ്ണമാണ്, "തരം" എന്നത്
തരം. ഓവർലാപ്പുചെയ്യുന്ന പകർപ്പുകളിൽ പരാജയപ്പെടാം. "നീക്കുക" എന്നതും കാണുക.

അസാധുവായ പകർപ്പ് (അസാധുവായ * src, void* dest, int nitems, തരം)

CopyD "പകർത്തുക" പോലെയാണ്, പക്ഷേ dest തിരികെ നൽകുന്നു. കംപൈലർമാരെ ടെയിൽ-കോൾ ചെയ്യാൻ പ്രോത്സാഹിപ്പിക്കുന്നതിന് ഉപയോഗപ്രദമാണ്
ഒപ്റ്റിമൈസ്.

void * CopyD(അസാധു* src, void* dest, int nitems, തരം)

XSUB-റൈറ്ററിന്റെ ഇന്റർഫേസ് C "memmove" ഫംഗ്‌ഷനിലേക്ക് നീക്കുക. "src" ആണ് ഉറവിടം,
"dest" എന്നത് ലക്ഷ്യസ്ഥാനമാണ്, "നൈറ്റങ്ങൾ" എന്നത് ഇനങ്ങളുടെ എണ്ണമാണ്, "തരം" എന്നത്
തരം. ഓവർലാപ്പിംഗ് നീക്കങ്ങൾ ചെയ്യാൻ കഴിയും. "പകർപ്പ്" എന്നതും കാണുക.

അസാധുവായ നീക്കം (അസാധുവായ * എസ്ആർസി, അസാധുവായ * ഡെസ്റ്റ്, ഇന്റർ നിറ്റംസ്, തരം)

MoveD "മൂവ്" പോലെയാണ്, പക്ഷേ ഡെസ്റ്റിലേക്ക് മടങ്ങുന്നു. കംപൈലർമാരെ ടെയിൽ-കോൾ ചെയ്യാൻ പ്രോത്സാഹിപ്പിക്കുന്നതിന് ഉപയോഗപ്രദമാണ്
ഒപ്റ്റിമൈസ്.

void * MoveD(അസാധു* src, void* dest, int nitems, തരം)

Newx C "malloc" ഫംഗ്‌ഷനിലേക്കുള്ള XSUB-റൈറ്ററിന്റെ ഇന്റർഫേസ്.

ഇതിലൂടെ ലഭിച്ച ഓർമ്മ വേണം മാത്രം "സുരക്ഷിതം" ഉപയോഗിച്ച് മോചിപ്പിക്കുക.

ക്സനുമ്ക്സ ൽ, Newx() സുഹൃത്തുക്കളും പഴയവരെ മാറ്റിസ്ഥാപിക്കുന്നു പുതിയത് () API, ആദ്യത്തേത് ഡ്രോപ്പ് ചെയ്യുന്നു
പരാമീറ്റർ, x, വിളിക്കുന്നവരെ സ്വയം തിരിച്ചറിയാൻ അനുവദിക്കുന്ന ഒരു ഡീബഗ് സഹായം. ഈ സഹായം
ഒരു പുതിയ ബിൽഡ് ഓപ്‌ഷൻ, PERL_MEM_LOG ("PERL_MEM_LOG" കാണുക
perlhacktips). പിന്തുണയ്ക്കുന്ന XS മൊഡ്യൂളുകളിൽ ഉപയോഗിക്കുന്നതിന് പഴയ API ഇപ്പോഴും ഉണ്ട്
പഴയ perls.

അസാധുവായ ന്യൂക്‌സ് (അസാധു* പി‌ടി‌ആർ, ഇന്റ് നിറ്റംസ്, തരം)

Newxc C "malloc" ഫംഗ്‌ഷനിലേക്കുള്ള XSUB-റൈറ്ററിന്റെ ഇന്റർഫേസ്, കാസ്റ്റിനൊപ്പം. ഇതും കാണുക
"ന്യൂഎക്സ്".

ഇതിലൂടെ ലഭിച്ച ഓർമ്മ വേണം മാത്രം "സുരക്ഷിതം" ഉപയോഗിച്ച് മോചിപ്പിക്കുക.

അസാധുവായ Newxc (void* ptr, int nitems, ടൈപ്പ്, കാസ്റ്റ്)

Newxz C "malloc" ഫംഗ്‌ഷനിലേക്കുള്ള XSUB-റൈറ്ററിന്റെ ഇന്റർഫേസ്. അനുവദിച്ച മെമ്മറി ആണ്
"memzero" ഉപയോഗിച്ച് പൂജ്യം. "Newx" എന്നതും കാണുക.

ഇതിലൂടെ ലഭിച്ച ഓർമ്മ വേണം മാത്രം "സുരക്ഷിതം" ഉപയോഗിച്ച് മോചിപ്പിക്കുക.

അസാധുവായ Newxz (void* ptr, int nitems, തരം)

വിഷം വിഷം വിത്ത്(0xEF) ഫ്രീഡ് മെമ്മറിയിലേക്കുള്ള ആക്‌സസ് പിടിക്കാൻ.

ശൂന്യമായ വിഷം (ശൂന്യമായ * ഡെസ്റ്റ്, ഇന്റ് നിറ്റംസ്, തരം)

വിഷരഹിതം
വിഷം വിത്ത്(0xEF) ഫ്രീഡ് മെമ്മറിയിലേക്കുള്ള ആക്‌സസ് പിടിക്കാൻ.

അസാധുവായ വിഷരഹിത (അസാധു* ഡെസ്റ്റ്, ഇന്റ് നിറ്റംസ്, തരം)

വിഷം പുതിയത്
വിഷം വിത്ത്(0xAB) അനുവദിച്ചിട്ടുള്ളതും എന്നാൽ ആരംഭിക്കാത്തതുമായ മെമ്മറിയിലേക്കുള്ള ആക്‌സസ് ലഭിക്കുന്നതിന്.

അസാധുവായ PoisonNew(അസാധുവായ* dest, int nitems, തരം)

വിഷം വിത്ത്
ഒരു ബൈറ്റ് പാറ്റേൺ ഉപയോഗിച്ച് മെമ്മറി നിറയ്ക്കുക (ഒരു ബൈറ്റ് വീണ്ടും വീണ്ടും ആവർത്തിക്കുന്നു).
അൺഇനീഷ്യലൈസ്ഡ് മെമ്മറി ആക്സസ് ചെയ്യാനുള്ള ശ്രമങ്ങൾ പ്രതീക്ഷിക്കുന്നു.

അസാധുവായ വിഷവിത്ത് (ശൂന്യമായ * ഡെസ്റ്റ്, ഇന്റ് നിറ്റംസ്, തരം,
U8 ബൈറ്റ്)

C "realloc" ഫംഗ്‌ഷനിലേക്ക് XSUB-റൈറ്ററിന്റെ ഇന്റർഫേസ് പുതുക്കുക.

ഇതിലൂടെ ലഭിച്ച ഓർമ്മ വേണം മാത്രം "സുരക്ഷിതം" ഉപയോഗിച്ച് മോചിപ്പിക്കുക.

അസാധുവായ പുതുക്കൽ (അസാധു* ptr, int nitems, തരം)

Renewc C "realloc" ഫംഗ്‌ഷനിലേക്കുള്ള XSUB-റൈറ്ററിന്റെ ഇന്റർഫേസ്, കാസ്റ്റിനൊപ്പം.

ഇതിലൂടെ ലഭിച്ച ഓർമ്മ വേണം മാത്രം "സുരക്ഷിതം" ഉപയോഗിച്ച് മോചിപ്പിക്കുക.

അസാധുവായ Renewc (void* ptr, int nitems, type, cast)

സുരക്ഷിതം
സി "ഫ്രീ" ഫംഗ്‌ഷനിലേക്കുള്ള XSUB-റൈറ്ററിന്റെ ഇന്റർഫേസ്.

ഇത് വേണം മാത്രം "Newx" ഉം സുഹൃത്തുക്കളും ഉപയോഗിച്ച് ലഭിച്ച മെമ്മറിയിൽ ഉപയോഗിക്കും.

അസാധുവായ സുരക്ഷിതത്വം (അസാധു* ptr)

savepv പേളിന്റെ "strdup()" പതിപ്പ്. പുതുതായി അനുവദിച്ച സ്ട്രിംഗിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു
"pv" യുടെ തനിപ്പകർപ്പാണ്. സ്ട്രിംഗിന്റെ വലുപ്പം നിർണ്ണയിക്കുന്നത് "strlen()" ആണ്
അതിനർത്ഥം അതിൽ ഉൾച്ചേർത്ത "NUL" പ്രതീകങ്ങൾ അടങ്ങിയിരിക്കണമെന്നില്ല കൂടാതെ ഒരു "NUL" ട്രെയിലിംഗ് ഉണ്ടായിരിക്കണം.
"സുരക്ഷിത()" ഉപയോഗിച്ച് പുതിയ സ്‌ട്രിംഗിനായി അനുവദിച്ച മെമ്മറി സ്വതന്ത്രമാക്കാം
പ്രവർത്തനം.

ചില പ്ലാറ്റ്‌ഫോമുകളിൽ, ഉദാഹരണത്തിന്, വിൻഡോസ്, ഒരു ത്രെഡിന്റെ ഉടമസ്ഥതയിലുള്ള എല്ലാ അനുവദിച്ച മെമ്മറിയും
ആ ത്രെഡ് അവസാനിക്കുമ്പോൾ ഡീലോക്കേറ്റ് ചെയ്തു. അതിനാൽ അത് സംഭവിക്കാതിരിക്കാൻ നിങ്ങൾക്ക് ആവശ്യമുണ്ടെങ്കിൽ, നിങ്ങൾ അത് ചെയ്യണം
"savesharedpv" പോലുള്ള പങ്കിട്ട മെമ്മറി ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുക.

char* savepv(const char* pv)

"strndup()" നിലവിലുണ്ടെങ്കിൽ എന്തായിരിക്കും എന്നതിന്റെ savepvn പേളിന്റെ പതിപ്പ്. a എന്നതിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു
"pv" ൽ നിന്നുള്ള ആദ്യത്തെ "ലെൻ" ബൈറ്റുകളുടെ തനിപ്പകർപ്പായ പുതുതായി അനുവദിച്ച സ്ട്രിംഗ്,
കൂടാതെ ഒരു പിന്നിലുള്ള "NUL" ബൈറ്റും. പുതിയ സ്ട്രിംഗിനായി അനുവദിച്ച മെമ്മറി സ്വതന്ത്രമാക്കാം
"സുരക്ഷിത()" ഫംഗ്‌ഷൻ ഉപയോഗിച്ച്.

ചില പ്ലാറ്റ്‌ഫോമുകളിൽ, ഉദാഹരണത്തിന്, വിൻഡോസ്, ഒരു ത്രെഡിന്റെ ഉടമസ്ഥതയിലുള്ള എല്ലാ അനുവദിച്ച മെമ്മറിയും
ആ ത്രെഡ് അവസാനിക്കുമ്പോൾ ഡീലോക്കേറ്റ് ചെയ്തു. അതിനാൽ അത് സംഭവിക്കാതിരിക്കാൻ നിങ്ങൾക്ക് ആവശ്യമുണ്ടെങ്കിൽ, നിങ്ങൾ അത് ചെയ്യണം
"savesharedpvn" പോലെയുള്ള പങ്കിട്ട മെമ്മറി ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുക.

char* savepvn(const char* pv, I32 len)

savepvs "savepvn" പോലെയാണ്, എന്നാൽ a എന്നതിന് പകരം അക്ഷരാർത്ഥത്തിൽ "NUL"-ടെർമിനേറ്റഡ് സ്ട്രിംഗ് എടുക്കുന്നു
സ്ട്രിംഗ്/നീളം ജോടി.

char* savepvs(const char*s)

savesharedpv
മെമ്മറിയിൽ ഡ്യൂപ്ലിക്കേറ്റ് സ്ട്രിംഗ് അനുവദിക്കുന്ന "savepv()" ന്റെ ഒരു പതിപ്പ്
ത്രെഡുകൾക്കിടയിൽ പങ്കിട്ടു.

char* savesharedpv(const char* pv)

savesharedpvn
മെമ്മറിയിൽ ഡ്യൂപ്ലിക്കേറ്റ് സ്ട്രിംഗ് അനുവദിക്കുന്ന "savepvn()" ന്റെ ഒരു പതിപ്പ്
ത്രെഡുകൾക്കിടയിൽ പങ്കിട്ടു. (ഒരു NULL പോയിന്റർ ഇല്ലാത്ത പ്രത്യേക വ്യത്യാസത്തിൽ
സ്വീകാര്യമായ)

char* savesharedpvn(const char *const pv,
കോൺസ്റ്റ് STRLEN ലെൻ)

savesharedpvs
മെമ്മറിയിൽ ഡ്യൂപ്ലിക്കേറ്റ് സ്ട്രിംഗ് അനുവദിക്കുന്ന "savepvs()" ന്റെ ഒരു പതിപ്പ്
ത്രെഡുകൾക്കിടയിൽ പങ്കിട്ടു.

char* savesharedpvs(const char*s)

savesharedsvpv
മെമ്മറിയിൽ ഡ്യൂപ്ലിക്കേറ്റ് സ്ട്രിംഗ് അനുവദിക്കുന്ന "savesharedpv()" ന്റെ ഒരു പതിപ്പ്
ത്രെഡുകൾക്കിടയിൽ പങ്കിടുന്നു.

char* savesharedsvpv(SV *sv)

സേവ്സ്വിപിവി
"savepv()"/"savepvn()" എന്നതിന്റെ ഒരു പതിപ്പ്, അതിൽ നിന്ന് തനിപ്പകർപ്പാക്കാനുള്ള സ്ട്രിംഗ് ലഭിക്കുന്നു
"SvPV()" ഉപയോഗിച്ച് SV-യിൽ കടന്നു

ചില പ്ലാറ്റ്‌ഫോമുകളിൽ, ഉദാഹരണത്തിന്, വിൻഡോസ്, ഒരു ത്രെഡിന്റെ ഉടമസ്ഥതയിലുള്ള എല്ലാ അനുവദിച്ച മെമ്മറിയും
ആ ത്രെഡ് അവസാനിക്കുമ്പോൾ ഡീലോക്കേറ്റ് ചെയ്തു. അതിനാൽ അത് സംഭവിക്കാതിരിക്കാൻ നിങ്ങൾക്ക് ആവശ്യമുണ്ടെങ്കിൽ, നിങ്ങൾ അത് ചെയ്യണം
"savesharedsvpv" പോലെയുള്ള പങ്കിട്ട മെമ്മറി ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുക.

char* savesvpv(SV* sv)

സ്ട്രക്റ്റ് കോപ്പി
ഒരു ഘടനയെ മറ്റൊന്നിലേക്ക് പകർത്താനുള്ള വാസ്തുവിദ്യാ-സ്വതന്ത്ര മാക്രോയാണിത്.

അസാധുവായ StructCopy (തരം *src, തരം *dest, തരം)

സീറോ C "memzero" ഫംഗ്‌ഷനിലേക്കുള്ള XSUB-റൈറ്ററിന്റെ ഇന്റർഫേസ്. "ഡെസ്റ്റ്" ആണ്
ലക്ഷ്യസ്ഥാനം, "നൈറ്റുകൾ" എന്നത് ഇനങ്ങളുടെ എണ്ണമാണ്, "തരം" എന്നത് തരം ആണ്.

പൂജ്യം അസാധുവാണ്

ZeroD "പൂജ്യം" പോലെയാണ്, പക്ഷേ തിരികെ വരുന്നു. കംപൈലർമാരെ ടെയിൽ-കോൾ ചെയ്യാൻ പ്രോത്സാഹിപ്പിക്കുന്നതിന് ഉപയോഗപ്രദമാണ്
ഒപ്റ്റിമൈസ്.

void * ZeroD(അസാധു* dest, int nitems, തരം)

കലര്പ്പായ പ്രവർത്തനങ്ങൾ

dump_c_backtrace
നൽകിയിരിക്കുന്ന എഫ്പിയിലേക്ക് സി ബാക്ക്ട്രെയിസ് ഡംപ് ചെയ്യുന്നു.

ഒരു ബാക്ക്ട്രെയിസ് വീണ്ടെടുക്കാൻ കഴിയുമെങ്കിൽ ശരിയും ഇല്ലെങ്കിൽ തെറ്റും നൽകുന്നു.

bool dump_c_backtrace(PerlIO* fp, int max_depth,
int skip)

fbm_compile
സ്ട്രിംഗ് ഉപയോഗിച്ച് വേഗത്തിലുള്ള തിരയലുകൾ നടത്തുന്നതിന് അത് വിശകലനം ചെയ്യുന്നു fbm_instr() - ദി
ബോയർ-മൂർ അൽഗോരിതം.

void fbm_compile(SV* sv, U32 ഫ്ലാഗുകൾ)

fbm_instr
"ബിഗ്", "ബിജെൻഡ്" എന്നിവയാൽ വേർതിരിച്ച സ്ട്രിംഗിലെ എസ്വിയുടെ സ്ഥാനം നൽകുന്നു. അത്
സ്ട്രിംഗ് കണ്ടെത്താൻ കഴിയുന്നില്ലെങ്കിൽ "NULL" നൽകുന്നു. "sv" ആയിരിക്കണമെന്നില്ല
fbm_compiled, പക്ഷേ തിരയൽ അത്ര വേഗത്തിലായിരിക്കില്ല.

char* fbm_instr(ഒപ്പ് ചെയ്യാത്ത ചാർ* വലുത്,
ഒപ്പിടാത്ത char* bigend, SV* littlestr,
U32 പതാകകൾ)

s1, s2 എന്നീ സ്‌ട്രിംഗുകളുടെ മുൻനിര ലെൻ ബൈറ്റുകൾ ഒരേ സാഹചര്യത്തിൽ ആണെങ്കിൽ foldEQ ശരിയാണെന്ന് നൽകുന്നു-
നിർവികാരമായി; അല്ലാത്തപക്ഷം തെറ്റ്. വലിയക്ഷരവും ചെറിയക്ഷരവും ASCII ശ്രേണി ബൈറ്റുകൾ പൊരുത്തപ്പെടുന്നു
തങ്ങളും അവരുടെ വിപരീത കേസിലെ എതിരാളികളും. നോൺ-കേസ്ഡ്, നോൺ-ആസ്കി ശ്രേണി
ബൈറ്റുകൾ അവയുമായി മാത്രം പൊരുത്തപ്പെടുന്നു.

I32 foldEQ(const char* a, const char* b, I32 len)

foldEQ_locale
s1, s2 എന്നീ സ്‌ട്രിംഗുകളുടെ മുൻനിര ലെൻ ബൈറ്റുകൾ ഒരേ കെയ്‌സ് ആണെങ്കിൽ ശരിയാണെന്ന് നൽകുന്നു-
നിലവിലെ പ്രദേശത്ത് നിർവികാരമായി; അല്ലാത്തപക്ഷം തെറ്റ്.

I32 foldEQ_locale(const char* a, const char* b,
I32 ലെൻ)

ഫോം ഒരു സ്പ്രിന്റ്എഫ്-സ്റ്റൈൽ ഫോർമാറ്റ് പാറ്റേണും പരമ്പരാഗത (എസ്വി ഇതര) ആർഗ്യുമെന്റുകളും എടുക്കുന്നു.
ഫോർമാറ്റ് ചെയ്ത സ്ട്രിംഗ് തിരികെ നൽകുന്നു.

(char *) Perl_form(pTHX_ കോൺസ്റ്റ് ചാർ* പാറ്റ്, ...)

ഒരു സ്ട്രിംഗ് (char *) ആവശ്യമുള്ള ഏത് സ്ഥലത്തും ഉപയോഗിക്കാം:

char * s = Perl_form("%d.%d",major,minor);

ഒരൊറ്റ സ്വകാര്യ ബഫർ ഉപയോഗിക്കുന്നു, അതിനാൽ നിങ്ങൾക്ക് നിരവധി സ്ട്രിംഗുകൾ ഫോർമാറ്റ് ചെയ്യണമെങ്കിൽ നിങ്ങൾ അത് ചെയ്യണം
മുമ്പത്തെ സ്ട്രിംഗുകൾ വ്യക്തമായി പകർത്തുക (നിങ്ങൾ പൂർത്തിയാക്കുമ്പോൾ പകർപ്പുകൾ സ്വതന്ത്രമാക്കുക).

ചാർ* ഫോം(കോൺസ്റ്റ് ചാർ* പാറ്റ്, ...)

getcwd_sv
നിലവിലുള്ള വർക്കിംഗ് ഡയറക്‌ടറി ഉപയോഗിച്ച് sv പൂരിപ്പിക്കുക

int getcwd_sv(SV* sv)

get_c_backtrace_dump
ഒരു SV, |depth|-ന്റെ ഡംപ് നൽകുന്നു കോൾ സ്റ്റാക്കിന്റെ ഫ്രെയിമുകൾ, |skip| ഒഴിവാക്കുന്നു
ഉള്ളിലുള്ളവ. 20 ആഴം സാധാരണയായി മതിയാകും.

അനുബന്ധ ഔട്ട്പുട്ട് ഇതുപോലെ കാണപ്പെടുന്നു:

... 1 10e004812:0082 Perl_croak util.c:1716 /usr/bin/perl 2
10df8d6d2:1d72 perl_parse perl.c:3975 /usr/bin/perl ...

ഫീൽഡുകൾ ടാബ്-വേർതിരിച്ചിരിക്കുന്നു. ആദ്യ നിര ഡെപ്ത് ആണ് (പൂജ്യം
ഏറ്റവും ഉള്ളിലെ നോൺ-സ്കിപ്പ് ഫ്രെയിം). ഹെക്‌സ്:ഓഫ്‌സെറ്റിൽ, പ്രോഗ്രാം എവിടെയാണ് ഹെക്‌സ്
കൌണ്ടർ S_parse_body-ൽ ഉണ്ടായിരുന്നു, കൂടാതെ :offset (നഷ്‌ടപ്പെട്ടിരിക്കാം) എത്രയാണെന്ന് പറയുന്നു
S_parse_body ഉള്ളിൽ പ്രോഗ്രാം കൗണ്ടർ ആയിരുന്നു.

util.c:1716 എന്നത് സോഴ്സ് കോഡ് ഫയലും ലൈൻ നമ്പറുമാണ്.

ദി /usr/bin/perl വ്യക്തമാണ് (പ്രതീക്ഷിക്കുന്നു).

അജ്ഞാതമായവ "-" ആണ്. അജ്ഞാതമായ കാര്യങ്ങൾ നിർഭാഗ്യവശാൽ വളരെ എളുപ്പത്തിൽ സംഭവിക്കാം: പ്ലാറ്റ്ഫോം ആണെങ്കിൽ
വിവരങ്ങൾ വീണ്ടെടുക്കുന്നതിനെ പിന്തുണയ്ക്കുന്നില്ല; ബൈനറിയിൽ ഡീബഗ് നഷ്‌ടമായാൽ
വിവരങ്ങൾ; ഒപ്റ്റിമൈസർ കോഡ് രൂപാന്തരപ്പെടുത്തിയിട്ടുണ്ടെങ്കിൽ, ഉദാഹരണത്തിന് ഇൻലൈനിംഗ്.

SV* get_c_backtrace_dump(int max_depth, int skip)

ibcmp ഇത് (! എന്നതിന്റെ പര്യായപദമാണ്. foldEQ())

I32 ibcmp(const char* a, const char* b, I32 len)

ibcmp_locale
ഇത് (!) എന്നതിന്റെ പര്യായപദമാണ്. foldEQ_locale())

I32 ibcmp_locale(const char* a, const char* b,
I32 ലെൻ)

ആണ്_സേഫ്_സിസ്‌കോൾ
നൽകിയിരിക്കുന്ന "pv" ൽ ആന്തരിക "NUL" പ്രതീകങ്ങളൊന്നും അടങ്ങിയിട്ടില്ലെന്ന് പരിശോധിക്കുക. എങ്കിൽ
ചെയ്യുന്നു, "errno" ENOENT ആയി സജ്ജീകരിക്കുക, ഓപ്ഷണലായി മുന്നറിയിപ്പ് നൽകുക, FALSE നൽകുക.

പേര് സുരക്ഷിതമാണെങ്കിൽ TRUE നൽകുക.

ഉപയോഗിച്ചത് IS_SAFE_SYSCALL() മാക്രോ.

bool is_safe_syscalll(const char *pv, STRLEN ലെൻ,
കോൺസ്റ്റ് ചാർ *എന്ത്,
കോൺസ്റ്റ് ചാർ *op_name)

memEQ രണ്ട് ബഫറുകൾ പരീക്ഷിക്കുക (അതിൽ ഉൾച്ചേർത്ത "NUL" പ്രതീകങ്ങൾ അടങ്ങിയിരിക്കാം, അവയാണോ എന്ന് നോക്കുക
തുല്യമായ. "len" പരാമീറ്റർ താരതമ്യം ചെയ്യേണ്ട ബൈറ്റുകളുടെ എണ്ണം സൂചിപ്പിക്കുന്നു. മടങ്ങുന്നു
തുല്യമാണെങ്കിൽ പൂജ്യം, അല്ലെങ്കിൽ തുല്യമല്ലെങ്കിൽ പൂജ്യമല്ല.

bool memEQ(char* s1, char* s2, STRLEN ലെൻ)

memNE രണ്ട് ബഫറുകൾ പരീക്ഷിക്കുക (അതിൽ ഉൾച്ചേർത്ത "NUL" പ്രതീകങ്ങൾ അടങ്ങിയിരിക്കാം, അവ ഉണ്ടോ എന്ന് നോക്കുക
തുല്യമല്ല. "len" പരാമീറ്റർ താരതമ്യം ചെയ്യേണ്ട ബൈറ്റുകളുടെ എണ്ണം സൂചിപ്പിക്കുന്നു. മടങ്ങുന്നു
തുല്യമല്ലെങ്കിൽ പൂജ്യം, തുല്യമാണെങ്കിൽ പൂജ്യമല്ല.

bool memNE(char* s1, char* s2, STRLEN ലെൻ)

കുഴപ്പം ഒരു സ്പ്രിന്റ്എഫ് ശൈലിയിലുള്ള ഫോർമാറ്റ് പാറ്റേണും ആർഗ്യുമെന്റ് ലിസ്റ്റും എടുക്കുക. ഇവ ഉത്പാദിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു
ഒരു സ്ട്രിംഗ് സന്ദേശം. സന്ദേശം ഒരു പുതിയ വരിയിൽ അവസാനിക്കുന്നില്ലെങ്കിൽ, അത് അങ്ങനെയായിരിക്കും
വിവരിച്ചതുപോലെ, കോഡിലെ നിലവിലെ സ്ഥാനത്തിന്റെ ചില സൂചനകളോടെ നീട്ടി
"mess_sv" എന്നതിനായി.

സാധാരണഗതിയിൽ, തത്ഫലമായുണ്ടാകുന്ന സന്ദേശം ഒരു പുതിയ മോർട്ടൽ എസ്വിയിൽ തിരികെ നൽകും. ആഗോള സമയത്ത്
ഈ ഫംഗ്‌ഷന്റെ ഉപയോഗങ്ങൾക്കിടയിൽ ഒരൊറ്റ എസ്‌വിയെ നശിപ്പിക്കാം.

എസ്വി * മെസ്(കോൺസ്റ്റ് ചാർ *പാറ്റ്, ...)

mess_sv നിലവിലുള്ളതിന്റെ ഒരു സൂചന ഉൾപ്പെടുത്തുന്നതിനായി ഉപയോക്താവിനെ ഉദ്ദേശിച്ചുള്ള ഒരു സന്ദേശം വികസിപ്പിക്കുന്നു
കോഡിലെ സ്ഥാനം, സന്ദേശം ഇതിനകം പൂർത്തിയായതായി തോന്നുന്നില്ലെങ്കിൽ.

"basemsg" എന്നത് പ്രാരംഭ സന്ദേശം അല്ലെങ്കിൽ വസ്തുവാണ്. ഒരു റഫറൻസ് ആണെങ്കിൽ, അത് ഉപയോഗിക്കും
ഈ ഫംഗ്‌ഷന്റെ ഫലമായിരിക്കുകയും ചെയ്യും. അല്ലെങ്കിൽ ഇത് ഒരു സ്ട്രിംഗായി ഉപയോഗിക്കുന്നു,
ഇത് ഇതിനകം ഒരു പുതിയ വരിയിൽ അവസാനിച്ചാൽ, അത് പൂർണ്ണമായി കണക്കാക്കുന്നു, ഫലം
ഈ ഫംഗ്‌ഷന്റെ ഒരേ സ്ട്രിംഗ് ആയിരിക്കും. സന്ദേശം എ എന്നതിൽ അവസാനിക്കുന്നില്ലെങ്കിൽ
newline, തുടർന്ന് "at foo.pl ലൈൻ 37" പോലുള്ള ഒരു സെഗ്മെന്റ് കൂട്ടിച്ചേർക്കും, ഒരുപക്ഷേ
നിർവ്വഹണത്തിന്റെ നിലവിലെ അവസ്ഥയെ സൂചിപ്പിക്കുന്ന മറ്റ് ഉപവാക്യങ്ങൾ. തത്ഫലമായുണ്ടാകുന്ന സന്ദേശം
ഒരു ഡോട്ടിലും ഒരു ന്യൂലൈനിലും അവസാനിക്കും.

സാധാരണഗതിയിൽ, തത്ഫലമായുണ്ടാകുന്ന സന്ദേശം ഒരു പുതിയ മോർട്ടൽ എസ്വിയിൽ തിരികെ നൽകും. ആഗോള സമയത്ത്
ഈ ഫംഗ്‌ഷന്റെ ഉപയോഗങ്ങൾക്കിടയിൽ ഒരൊറ്റ എസ്‌വിയെ നശിപ്പിക്കാം. "ഉപഭോഗം" എങ്കിൽ
ശരിയാണ്, അപ്പോൾ ഫംഗ്‌ഷൻ പരിഷ്‌ക്കരിക്കുന്നതിനും തിരികെ നൽകുന്നതിനും അനുവദനീയമാണ് (പക്ഷേ ആവശ്യമില്ല).
ഒരു പുതിയ SV അനുവദിക്കുന്നതിന് പകരം "basemsg".

SV * mess_sv(SV *basemsg, bool ഉപഭോഗം)

my_snprintf
C ലൈബ്രറി "snprintf" പ്രവർത്തനക്ഷമത, ലഭ്യമാണെങ്കിൽ, സ്റ്റാൻഡേർഡുകൾ-അനുസരണം (ഉപയോഗിക്കുന്നു
"vsnprintf", യഥാർത്ഥത്തിൽ). എന്നിരുന്നാലും, "vsnprintf" ലഭ്യമല്ലെങ്കിൽ, ചെയ്യും
നിർഭാഗ്യവശാൽ ബഫറിനെ മറികടക്കാൻ കഴിയുന്ന സുരക്ഷിതമല്ലാത്ത "vsprintf" ഉപയോഗിക്കുക (ഒരു ഉണ്ട്
പരിശോധന മറികടക്കുക, പക്ഷേ അത് വളരെ വൈകിയേക്കാം). പകരം "sv_catpvf" ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക, അല്ലെങ്കിൽ
"vsnprintf" ലഭിക്കുന്നു.

int my_snprintf(char *buffer, const Size_t len,
കോൺസ്റ്റ് ചാർ * ഫോർമാറ്റ്, ...)

my_sprintf
C ലൈബ്രറി "sprintf", ആവശ്യമെങ്കിൽ പൊതിഞ്ഞ്, അത് തിരികെ നൽകുമെന്ന് ഉറപ്പാക്കുക
ബഫറിൽ എഴുതിയിരിക്കുന്ന സ്ട്രിംഗിന്റെ നീളം. അപൂർവമായ പ്രീ-ANSI സിസ്റ്റങ്ങൾക്ക് മാത്രമേ ആവശ്യമുള്ളൂ
റാപ്പർ ഫംഗ്‌ഷൻ - സാധാരണയായി ഇത് "sprintf" എന്നതിലേക്കുള്ള നേരിട്ടുള്ള കോളാണ്.

int my_sprintf(char *buffer, const char *pat, ...)

my_strlcat
ലഭ്യമെങ്കിൽ C ലൈബ്രറി "strlcat" അല്ലെങ്കിൽ അതിന്റെ ഒരു Perl നടപ്പിലാക്കൽ. ഈ
C "NUL"-ടെർമിനേറ്റഡ് സ്ട്രിംഗുകളിൽ പ്രവർത്തിക്കുന്നു.

"my_strlcat()" "dst" ന്റെ അവസാനം "src" എന്ന സ്ട്രിംഗ് കൂട്ടിച്ചേർക്കുന്നു. ഇത് പരമാവധി കൂട്ടിച്ചേർക്കും
"വലിപ്പം - strlen(dst) - 1" പ്രതീകങ്ങൾ. അത് പിന്നീട് "NUL" അവസാനിക്കും, "വലിപ്പം" ഇല്ലെങ്കിൽ
0 ആണ് അല്ലെങ്കിൽ യഥാർത്ഥ "dst" സ്ട്രിംഗ് "വലിപ്പം" എന്നതിനേക്കാൾ നീളമുള്ളതായിരുന്നു (പ്രായോഗികമായി ഇത് ചെയ്യണം
ഒന്നുകിൽ "വലിപ്പം" തെറ്റാണ് അല്ലെങ്കിൽ "dst" a അല്ല എന്നർത്ഥം വരുന്നതിനാൽ സംഭവിക്കരുത്
ശരിയായ "NUL" - അവസാനിപ്പിച്ച സ്ട്രിംഗ്).

"വലുപ്പം" എന്നത് ലക്ഷ്യസ്ഥാന ബഫറിന്റെ പൂർണ്ണ വലുപ്പമാണെന്നും അതിന്റെ ഫലമാണ്
"NUL" ആയിരിക്കുമെന്ന് ഉറപ്പുനൽകുന്നു - റൂം ഉണ്ടെങ്കിൽ അവസാനിപ്പിക്കും. "NUL" എന്നതിനുള്ള മുറി ശ്രദ്ധിക്കുക
"വലിപ്പത്തിൽ" ഉൾപ്പെടുത്തണം.

Size_t my_strlcat(char *dst, const char *src,
Size_t വലുപ്പം)

my_strlcpy
ലഭ്യമെങ്കിൽ C ലൈബ്രറി "strlcpy" അല്ലെങ്കിൽ അതിന്റെ ഒരു Perl നടപ്പിലാക്കൽ. ഈ
C "NUL"-ടെർമിനേറ്റഡ് സ്ട്രിംഗുകളിൽ പ്രവർത്തിക്കുന്നു.

"my_strlcpy()" "src" എന്ന സ്ട്രിംഗിൽ നിന്ന് "dst" ലേക്ക് "size - 1" പ്രതീകങ്ങൾ വരെ പകർത്തുന്നു,
"NUL" - "വലിപ്പം" 0 അല്ലെങ്കിൽ ഫലം അവസാനിപ്പിക്കുന്നു.

Size_t my_strlcpy(char *dst, const char *src,
Size_t വലുപ്പം)

my_vsnprintf
C ലൈബ്രറി "vsnprintf" ലഭ്യമാണെങ്കിൽ സ്റ്റാൻഡേർഡുകൾ-അനുസരണം. എന്നിരുന്നാലും, എങ്കിൽ
"vsnprintf" ലഭ്യമല്ല, നിർഭാഗ്യവശാൽ സുരക്ഷിതമല്ലാത്ത "vsprintf" ഉപയോഗിക്കും
ബഫറിനെ മറികടക്കാൻ കഴിയുന്ന (ഒരു ഓവർറൺ ചെക്ക് ഉണ്ട്, പക്ഷേ അതും ആകാം
വൈകി). പകരം "sv_catpvf" ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക, അല്ലെങ്കിൽ "vsnprintf" നേടുക.

int my_vsnprintf(char *buffer, const Size_t len,
കോൺസ്റ്റ് ചാർ * ഫോർമാറ്റ്, va_list ap)

PERL_SYS_INIT
പ്രവർത്തിപ്പിക്കുന്നതിന് ആവശ്യമായ സി റൺടൈം എൻവയോൺമെന്റിന്റെ സിസ്റ്റം-നിർദ്ദിഷ്ട ട്യൂൺ അപ്പ് നൽകുന്നു
പേൾ വ്യാഖ്യാതാക്കൾ. ഏതെങ്കിലും പേൾ സൃഷ്ടിക്കുന്നതിന് മുമ്പ് ഇത് ഒരു തവണ മാത്രമേ വിളിക്കാവൂ
വ്യാഖ്യാതാക്കൾ.

അസാധുവായ PERL_SYS_INIT(int *argc, char*** argv)

PERL_SYS_INIT3
പ്രവർത്തിപ്പിക്കുന്നതിന് ആവശ്യമായ സി റൺടൈം എൻവയോൺമെന്റിന്റെ സിസ്റ്റം-നിർദ്ദിഷ്ട ട്യൂൺ അപ്പ് നൽകുന്നു
പേൾ വ്യാഖ്യാതാക്കൾ. ഏതെങ്കിലും പേൾ സൃഷ്ടിക്കുന്നതിന് മുമ്പ് ഇത് ഒരു തവണ മാത്രമേ വിളിക്കാവൂ
വ്യാഖ്യാതാക്കൾ.

അസാധുവായ PERL_SYS_INIT3(int *argc, char*** argv,
char*** env)

PERL_SYS_TERM
Perl പ്രവർത്തിപ്പിച്ചതിന് ശേഷം സി റൺടൈം എൻവയോൺമെന്റിന്റെ സിസ്റ്റം-നിർദ്ദിഷ്ട ക്ലീൻ അപ്പ് നൽകുന്നു
വ്യാഖ്യാതാക്കൾ. ശേഷിക്കുന്ന പേൾ സ്വതന്ത്രമാക്കിയതിന് ശേഷം ഇത് ഒരിക്കൽ മാത്രമേ വിളിക്കാവൂ
വ്യാഖ്യാതാക്കൾ.

അസാധുവാണ് PERL_SYS_TERM()

quadmath_format_needed
quadmath_format_needed() ഫോർമാറ്റ് സ്ട്രിംഗിൽ at അടങ്ങിയിരിക്കുന്നതായി തോന്നുന്നുവെങ്കിൽ true എന്ന് നൽകുന്നു
കുറഞ്ഞത് ഒരു നോൺ-ക്യു-പ്രിഫിക്‌സ്ഡ് %[efgaEFGA] ഫോർമാറ്റ് സ്‌പെസിഫയർ അല്ലെങ്കിൽ തെറ്റായി നൽകുന്നു.

ഫോർമാറ്റ് സ്പെസിഫയർ കണ്ടെത്തൽ പൂർണ്ണമായ printf-സിന്റാക്സ് കണ്ടെത്തലല്ല, മറിച്ച് അത്
ഏറ്റവും സാധാരണമായ കേസുകൾ പിടിക്കണം.

ശരി തിരികെ നൽകിയാൽ, ആ വാദങ്ങൾ വേണം സിദ്ധാന്തത്തിൽ പ്രോസസ്സ് ചെയ്യണം
quadmath_snprintf(), എന്നാൽ അത്തരം ഒന്നിൽ കൂടുതൽ ഫോർമാറ്റ് സ്പെസിഫയർ ഉണ്ടെങ്കിൽ (കാണുക
"quadmath_format_single"), അതിനപ്പുറം മറ്റെന്തെങ്കിലും ഉണ്ടെങ്കിൽ (പോലും
ഒരൊറ്റ ബൈറ്റ്), അവർ ഒന്നും കഴിയില്ല കാരണം പ്രോസസ്സ് ചെയ്യും quadmath_snprintf() വളരെ ആണ്
കർശനമായ, ഒരു ഫോർമാറ്റ് സ്‌പെക്ക് മാത്രം സ്വീകരിക്കുന്നു, മറ്റൊന്നുമല്ല. ഈ സാഹചര്യത്തിൽ, കോഡ്
ഒരുപക്ഷേ പരാജയപ്പെടണം.

bool quadmath_format_needed(const char* ഫോർമാറ്റ്)

quadmath_format_single
quadmath_snprintf() അതിന്റെ ഫോർമാറ്റ് സ്ട്രിംഗിനെക്കുറിച്ച് വളരെ കർശനമാണ്, അത് പരാജയപ്പെടും,
ഫോർമാറ്റ് അസാധുവാണെങ്കിൽ -1 തിരികെ നൽകുന്നു. ഇത് കൃത്യമായി ഒരു ഫോർമാറ്റ് സ്പെസിഫിക്കേഷൻ സ്വീകരിക്കുന്നു.

quadmath_format_single() ഉദ്ദേശിച്ച സിംഗിൾ സ്‌പെക്ക് നല്ലതാണെന്ന് പരിശോധിക്കുന്നു: ആരംഭിക്കുന്നു
"%" എന്നതിനൊപ്പം, ഒരു "%" മാത്രമേയുള്ളൂ, "[efgaEFGA]" എന്നതിൽ അവസാനിക്കുന്നു, അതിനുമുമ്പ് "Q" ഉണ്ട്. ഈ
പൂർണ്ണമായ "printf വാക്യഘടന പരിശോധന" അല്ല, അടിസ്ഥാനകാര്യങ്ങൾ മാത്രം.

ഫോർമാറ്റ് സാധുവാണെങ്കിൽ അത് നൽകുന്നു, ഇല്ലെങ്കിൽ NULL.

quadmath_format_single() നഷ്‌ടമായ "Q" ൽ യഥാർത്ഥത്തിൽ പാച്ച് ചെയ്യാൻ കഴിയും, എങ്കിൽ
ആവശ്യമായ. ഈ സാഹചര്യത്തിൽ അത് ഫോർമാറ്റിന്റെ പരിഷ്കരിച്ച പകർപ്പ് തിരികെ നൽകും, ഏത് The
വിളിക്കുന്നയാൾ ഉദ്ദേശിക്കുന്ന ആവശ്യം ലേക്ക് സ്വതന്ത്രമായി.

"quadmath_format_needed" എന്നതും കാണുക.

const char* quadmath_format_single(const char* ഫോർമാറ്റ്)

READ_XDIGIT
ഒരു ASCII-റേഞ്ച് ഹെക്‌സ് അക്കത്തിന്റെ മൂല്യം നൽകുകയും സ്‌ട്രിംഗ് പോയിന്റർ മുന്നോട്ട് കൊണ്ടുപോകുകയും ചെയ്യുന്നു.
isXDIGIT(*str) ശരിയാകുമ്പോൾ മാത്രമേ പെരുമാറ്റം നന്നായി നിർവചിക്കപ്പെടൂ.

U8 READ_XDIGIT(char str*)

strEQ രണ്ട് സ്ട്രിംഗുകൾ തുല്യമാണോ എന്നറിയാൻ പരിശോധിക്കുക. ശരിയോ തെറ്റോ നൽകുന്നു.

bool strEQ(char* s1, char* s2)

strGE ആദ്യത്തേത് "s1" എന്നതിനേക്കാൾ വലുതാണോ തുല്യമാണോ എന്നറിയാൻ രണ്ട് സ്ട്രിംഗുകൾ പരീക്ഷിക്കുക
രണ്ടാമത്, "s2". ശരിയോ തെറ്റോ നൽകുന്നു.

bool strGE(char* s1, char* s2)

strGT ആദ്യത്തേത് "s1" രണ്ടാമത്തേത് "s2" എന്നതിനേക്കാൾ വലുതാണോ എന്ന് കാണാൻ രണ്ട് സ്ട്രിംഗുകൾ പരീക്ഷിക്കുക.
ശരിയോ തെറ്റോ നൽകുന്നു.

bool strGT(char* s1, char* s2)

strLE ആദ്യത്തേത് "s1" രണ്ടാമത്തേതിനേക്കാൾ കുറവാണോ തുല്യമാണോ എന്നറിയാൻ രണ്ട് സ്ട്രിംഗുകൾ പരീക്ഷിക്കുക,
"s2". ശരിയോ തെറ്റോ നൽകുന്നു.

bool strLE(char* s1, char* s2)

ആദ്യത്തേത് "s1" രണ്ടാമത്തേത് "s2" എന്നതിനേക്കാൾ കുറവാണോ എന്ന് കാണാൻ strLT രണ്ട് സ്ട്രിംഗുകൾ പരീക്ഷിക്കുക.
ശരിയോ തെറ്റോ നൽകുന്നു.

bool strLT(char* s1, char* s2)

strNE രണ്ട് സ്ട്രിംഗുകൾ വ്യത്യസ്തമാണോ എന്ന് പരിശോധിക്കാൻ പരിശോധിക്കുക. ശരിയോ തെറ്റോ നൽകുന്നു.

bool strNE(char* s1, char* s2)

strnEQ രണ്ട് സ്ട്രിംഗുകൾ തുല്യമാണോ എന്ന് പരിശോധിക്കാൻ. "len" പരാമീറ്റർ സൂചിപ്പിക്കുന്നത്
താരതമ്യം ചെയ്യാനുള്ള ബൈറ്റുകളുടെ എണ്ണം. ശരിയോ തെറ്റോ നൽകുന്നു. ("strncmp" എന്നതിനുള്ള റാപ്പർ).

bool strnEQ(char* s1, char* s2, STRLEN ലെൻ)

strnNE രണ്ട് സ്ട്രിംഗുകൾ വ്യത്യസ്തമാണോ എന്ന് പരിശോധിക്കാൻ പരിശോധിക്കുക. "len" പരാമീറ്റർ സൂചിപ്പിക്കുന്നത്
താരതമ്യം ചെയ്യാനുള്ള ബൈറ്റുകളുടെ എണ്ണം. ശരിയോ തെറ്റോ നൽകുന്നു. ("strncmp" എന്നതിനുള്ള റാപ്പർ).

bool strnNE(char* s1, char* s2, STRLEN ലെൻ)

sv_destroyable
പങ്കിടൽ ഇല്ലെങ്കിൽ വസ്തു നശിപ്പിക്കപ്പെടുമെന്ന് റിപ്പോർട്ട് ചെയ്യുന്ന ഡമ്മി ദിനചര്യ
മൊഡ്യൂൾ നിലവിലുണ്ട്. ഇത് അതിന്റെ സിംഗിൾ എസ് വി ആർഗ്യുമെന്റ് അവഗണിക്കുകയും 'സത്യം' നൽകുകയും ചെയ്യുന്നു. വരെ നിലവിലുണ്ട്
NULL ഫംഗ്‌ഷൻ പോയിന്ററിനായുള്ള പരിശോധന ഒഴിവാക്കുക, കാരണം അത് മുന്നറിയിപ്പ് നൽകാനിടയുണ്ട്
കർശനമായ ചില തലങ്ങൾ.

bool sv_destroyable(SV *sv)

sv_nosharing
പങ്കിടൽ മൊഡ്യൂൾ നിലവിലില്ലാത്തപ്പോൾ ഒരു SV "പങ്കിടുന്ന" ഡമ്മി ദിനചര്യ. അഥവാ
അത് "പൂട്ടുന്നു". അല്ലെങ്കിൽ "അൺലോക്ക്" ചെയ്യുക. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, അതിന്റെ സിംഗിൾ എസ്വി ആർഗ്യുമെന്റ് അവഗണിക്കുന്നു.
ഒരു NULL ഫംഗ്‌ഷൻ പോയിന്ററിനായുള്ള പരിശോധന ഒഴിവാക്കാനും അതിന് സാധ്യതയുള്ളതിനാലും നിലവിലുണ്ട്
കർശനമായ ചില തലങ്ങളിൽ മുന്നറിയിപ്പ് നൽകുക.

അസാധുവായ sv_nosharing(SV *sv)

vmess "pat" ഉം "args" ഉം ഒരു sprintf ശൈലിയിലുള്ള ഫോർമാറ്റ് പാറ്റേണും എൻക്യാപ്‌സലേറ്റഡ് ആർഗ്യുമെന്റുമാണ്
പട്ടിക. ഒരു സ്ട്രിംഗ് സന്ദേശം സൃഷ്ടിക്കാൻ ഇവ ഉപയോഗിക്കുന്നു. സന്ദേശം അവസാനിക്കുന്നില്ലെങ്കിൽ
ഒരു പുതിയ ലൈൻ ഉപയോഗിച്ച്, അത് നിലവിലെ ചില സൂചനകളോടെ വിപുലീകരിക്കും
"mess_sv" എന്നതിന് വിവരിച്ചിരിക്കുന്നതുപോലെ, കോഡിലെ സ്ഥാനം.

സാധാരണഗതിയിൽ, തത്ഫലമായുണ്ടാകുന്ന സന്ദേശം ഒരു പുതിയ മോർട്ടൽ എസ്വിയിൽ തിരികെ നൽകും. ആഗോള സമയത്ത്
ഈ ഫംഗ്‌ഷന്റെ ഉപയോഗങ്ങൾക്കിടയിൽ ഒരൊറ്റ എസ്‌വിയെ നശിപ്പിക്കാം.

SV * vmess(const char *pat, va_list *args)

എംആർഒ പ്രവർത്തനങ്ങൾ

ഈ ഫംഗ്‌ഷനുകൾ perl ക്ലാസുകളുടെ രീതി റെസലൂഷൻ ക്രമവുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു

mro_get_linear_isa
നൽകിയിരിക്കുന്ന സ്‌റ്റാഷിനായി mro ലീനിയറൈസേഷൻ നൽകുന്നു. സ്ഥിരസ്ഥിതിയായി, ഇത് ആയിരിക്കും
"mro_get_linear_isa_dfs" എന്നത് മറ്റേതെങ്കിലും MRO പ്രാബല്യത്തിൽ ഇല്ലെങ്കിൽ ലഭിക്കുന്നത്
സ്റ്റാഷ്. റിട്ടേൺ മൂല്യം ഒരു വായന-മാത്രം AV* ആണ്.

നിങ്ങൾ സംഭരിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, റിട്ടേൺ മൂല്യത്തിൽ "SvREFCNT_inc()"-ന് നിങ്ങൾ ഉത്തരവാദിയാണ്
അത് എവിടെയെങ്കിലും അർദ്ധ-ശാശ്വതമായി (അല്ലെങ്കിൽ അത് നിങ്ങളുടെ കീഴിൽ നിന്ന് ഇല്ലാതാക്കിയേക്കാം
അടുത്ത തവണ കാഷെ അസാധുവാക്കുന്നു).

AV* mro_get_linear_isa(HV* stash)

mro_method_changed_in
തന്നിരിക്കുന്ന സ്‌റ്റാഷിന്റെ ഏതെങ്കിലും ചൈൽഡ് ക്ലാസുകളിൽ രീതി കാഷെ ചെയ്യൽ അസാധുവാക്കുന്നു, അങ്ങനെ അവർ
ഇതിലെ മാറ്റങ്ങൾ ശ്രദ്ധിച്ചേക്കാം.

മികച്ച രീതിയിൽ, "PL_sub_generation++" ന്റെ എല്ലാ സന്ദർഭങ്ങളും പുറത്തുള്ള perl ഉറവിടത്തിൽ mro.c
ഇതിലേക്കുള്ള കോളുകൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കേണ്ടതാണ്.

ഒരു രീതി പുനർ നിർവചിക്കാവുന്ന മിക്ക പൊതുവഴികളും പേൾ സ്വയമേവ കൈകാര്യം ചെയ്യുന്നു.
എന്നിരുന്നാലും, നിങ്ങൾക്ക് ഒരു സ്റ്റാഷിൽ ഒരു രീതി മാറ്റാൻ ചില വഴികളുണ്ട്
കാഷെ കോഡ് ശ്രദ്ധിക്കുന്നു, ഈ സാഹചര്യത്തിൽ നിങ്ങൾ പിന്നീട് ഈ രീതിയെ വിളിക്കേണ്ടതുണ്ട്:

1) XS കോഡിൽ നിന്നുള്ള സ്റ്റാഷ് HV എൻട്രികൾ നേരിട്ട് കൈകാര്യം ചെയ്യുന്നു.

2) ക്രമത്തിൽ ഒരു സ്റ്റാഷ് എൻട്രിയിലേക്ക് ഒരു വായന മാത്രമുള്ള സ്കെയിലർ സ്ഥിരാങ്കത്തിലേക്ക് ഒരു റഫറൻസ് നൽകുന്നു
സ്ഥിരമായ ഒരു സബ്റൂട്ടീൻ സൃഷ്ടിക്കാൻ (constance.pm ചെയ്യുന്നത് പോലെ).

ഇതേ രീതി ശുദ്ധമായ പേളിൽ നിന്നും ലഭ്യമാണ്,
"mro::method_changed_in(classname)".

അസാധുവായ mro_method_changed_in(HV* stash)

mro_register
ഒരു ഇഷ്‌ടാനുസൃത mro പ്ലഗിൻ രജിസ്റ്റർ ചെയ്യുന്നു. വിശദാംശങ്ങൾക്ക് perlmroapi കാണുക.

mro_register അസാധുവാണ് ( const struct mro_alg *mro)

മൾട്ടിക്കൽ പ്രവർത്തനങ്ങൾ

dMULTICALL
ഒരു മൾട്ടികോളിനായി ലോക്കൽ വേരിയബിളുകൾ പ്രഖ്യാപിക്കുക. perlcall-ൽ "ലൈറ്റ്വെയ്റ്റ് കോൾബാക്കുകൾ" കാണുക.

dMULTICALL;

മൾട്ടികാൾ
ഭാരം കുറഞ്ഞ ഒരു കോൾബാക്ക് ചെയ്യുക. perlcall-ൽ "ലൈറ്റ്വെയ്റ്റ് കോൾബാക്കുകൾ" കാണുക.

മൾട്ടികാൾ;

POP_MULTICALL
ഭാരം കുറഞ്ഞ കോൾബാക്കിനുള്ള ക്ലോസിംഗ് ബ്രാക്കറ്റ്. "ലൈറ്റ്വെയ്റ്റ് കോൾബാക്കുകൾ" കാണുക
perlcall.

POP_MULTICALL;

PUSH_MULTICALL
കനംകുറഞ്ഞ കോൾബാക്കിനായി ബ്രാക്കറ്റ് തുറക്കുന്നു. "ലൈറ്റ്വെയ്റ്റ് കോൾബാക്കുകൾ" കാണുക
perlcall.

PUSH_MULTICALL;

സംഖ്യാ ഫംഗ്ഷനുകളും

ഗ്രോക്ക്_ബിൻ
ഒരു ബൈനറി സംഖ്യയെ പ്രതിനിധീകരിക്കുന്ന ഒരു സ്ട്രിംഗ് സംഖ്യാ രൂപത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു.

പ്രവേശന സമയത്ത് തുടക്കം ഒപ്പം *len സ്കാൻ ചെയ്യാൻ സ്ട്രിംഗ് നൽകുക, *പതാകകൾ പരിവർത്തന പതാകകൾ നൽകുന്നു,
ഒപ്പം ഫലം NULL അല്ലെങ്കിൽ NV-യിലേക്കുള്ള പോയിന്റർ ആയിരിക്കണം. സ്കാൻ അവസാനത്തോടെ നിർത്തുന്നു
സ്ട്രിംഗ്, അല്ലെങ്കിൽ ആദ്യത്തെ അസാധുവായ പ്രതീകം. "PERL_SCAN_SILENT_ILLDIGIT" സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ
in *പതാകകൾ, ഒരു അസാധുവായ പ്രതീകം നേരിടുന്നത് ഒരു മുന്നറിയിപ്പും ട്രിഗർ ചെയ്യും. ഓൺ
മടക്കം *len സ്‌കാൻ ചെയ്‌ത സ്‌ട്രിംഗിന്റെ നീളത്തിലേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു, ഒപ്പം *പതാകകൾ ഔട്ട്പുട്ട് നൽകുന്നു
പതാകകൾ.

മൂല്യം <= "UV_MAX" ആണെങ്കിൽ അത് UV ആയി നൽകും, ഔട്ട്‌പുട്ട് ഫ്ലാഗുകൾ വ്യക്തമാണ്,
ഒന്നും എഴുതിയിട്ടില്ല *ഫലമായി. മൂല്യം > UV_MAX ആണെങ്കിൽ "grok_bin" നൽകുന്നു
UV_MAX, ഔട്ട്‌പുട്ട് ഫ്ലാഗുകളിൽ "PERL_SCAN_GREATER_THAN_UV_MAX" സജ്ജീകരിക്കുകയും എഴുതുകയും ചെയ്യുന്നു
അതിന്റെ മൂല്യം *ഫലമായി (അല്ലെങ്കിൽ മൂല്യം ഉപേക്ഷിക്കപ്പെടും ഫലം NULL ആണ്).

ബൈനറി നമ്പർ ഓപ്‌ഷണലായി "0b" അല്ലെങ്കിൽ "b" ഉപയോഗിച്ച് പ്രിഫിക്‌സ് ചെയ്തേക്കാം
"PERL_SCAN_DISALLOW_PREFIX" സജ്ജീകരിച്ചിരിക്കുന്നു *പതാകകൾ പ്രവേശന സമയത്ത്. എങ്കിൽ
"PERL_SCAN_ALLOW_UNDERSCORES" സജ്ജീകരിച്ചിരിക്കുന്നു *പതാകകൾ അപ്പോൾ ബൈനറി നമ്പർ '_' ഉപയോഗിച്ചേക്കാം
അക്കങ്ങൾ വേർതിരിക്കുന്നതിനുള്ള പ്രതീകങ്ങൾ.

UV grok_bin(const char* start, STRLEN* len_p,
I32* പതാകകൾ, NV *ഫലം)

ഗ്രോക്ക്_ഹെക്സ്
ഒരു ഹെക്സ് സംഖ്യയെ പ്രതിനിധീകരിക്കുന്ന ഒരു സ്ട്രിംഗ് സംഖ്യാ രൂപത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു.

പ്രവേശന സമയത്ത് തുടക്കം ഒപ്പം *len_p സ്കാൻ ചെയ്യാൻ സ്ട്രിംഗ് നൽകുക, *പതാകകൾ പരിവർത്തന പതാകകൾ നൽകുന്നു,
ഒപ്പം ഫലം NULL അല്ലെങ്കിൽ NV-യിലേക്കുള്ള പോയിന്റർ ആയിരിക്കണം. സ്കാൻ അവസാനത്തോടെ നിർത്തുന്നു
സ്ട്രിംഗ്, അല്ലെങ്കിൽ ആദ്യത്തെ അസാധുവായ പ്രതീകം. "PERL_SCAN_SILENT_ILLDIGIT" സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ
in *പതാകകൾ, ഒരു അസാധുവായ പ്രതീകം നേരിടുന്നത് ഒരു മുന്നറിയിപ്പും ട്രിഗർ ചെയ്യും. ഓൺ
മടക്കം *len സ്‌കാൻ ചെയ്‌ത സ്‌ട്രിംഗിന്റെ നീളത്തിലേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു, ഒപ്പം *പതാകകൾ ഔട്ട്പുട്ട് നൽകുന്നു
പതാകകൾ.

മൂല്യം <= UV_MAX ആണെങ്കിൽ അത് UV ആയി നൽകും, ഔട്ട്‌പുട്ട് ഫ്ലാഗുകൾ വ്യക്തമാണ്, കൂടാതെ
ഒന്നും എഴുതിയിട്ടില്ല *ഫലമായി. മൂല്യം > UV_MAX ആണെങ്കിൽ "grok_hex" നൽകുന്നു
UV_MAX, ഔട്ട്‌പുട്ട് ഫ്ലാഗുകളിൽ "PERL_SCAN_GREATER_THAN_UV_MAX" സജ്ജീകരിക്കുകയും എഴുതുകയും ചെയ്യുന്നു
അതിന്റെ മൂല്യം *ഫലമായി (അല്ലെങ്കിൽ മൂല്യം ഉപേക്ഷിക്കപ്പെടും ഫലം NULL ആണ്).

ഹെക്‌സ് നമ്പർ ഓപ്‌ഷണലായി "0x" അല്ലെങ്കിൽ "x" ഉപയോഗിച്ച് പ്രിഫിക്‌സ് ചെയ്‌തേക്കാം
"PERL_SCAN_DISALLOW_PREFIX" സജ്ജീകരിച്ചിരിക്കുന്നു *പതാകകൾ പ്രവേശന സമയത്ത്. എങ്കിൽ
"PERL_SCAN_ALLOW_UNDERSCORES" സജ്ജീകരിച്ചിരിക്കുന്നു *പതാകകൾ അപ്പോൾ ഹെക്‌സ് നമ്പർ '_' ഉപയോഗിച്ചേക്കാം
അക്കങ്ങൾ വേർതിരിക്കുന്നതിനുള്ള പ്രതീകങ്ങൾ.

UV grok_hex(const char* start, STRLEN* len_p,
I32* പതാകകൾ, NV *ഫലം)

grok_infnan
വേണ്ടി സഹായി grok_number(), "ഇൻഫിനിറ്റി" അല്ലെങ്കിൽ "അല്ല എ" എന്ന അക്ഷരവിന്യാസത്തിന്റെ വിവിധ രീതികൾ സ്വീകരിക്കുന്നു
നമ്പർ", കൂടാതെ ഇനിപ്പറയുന്ന ഫ്ലാഗ് കോമ്പിനേഷനുകളിലൊന്ന് നൽകുന്നു:

IS_NUMBER_INFINITE
IS_NUMBER_NAN
IS_NUMBER_INFINITE | IS_NUMBER_NEG
IS_NUMBER_NAN | IS_NUMBER_NEG
0

IS_NUMBER_TRAILING ഉപയോഗിച്ച് |-എഡ്.

ഒരു ഇൻഫിനിറ്റി അല്ലെങ്കിൽ ഒരു സംഖ്യയല്ല തിരിച്ചറിഞ്ഞാൽ, *sp ഒരു ബൈറ്റിലേക്ക് പോയിന്റ് ചെയ്യും
അംഗീകൃത സ്ട്രിംഗിന്റെ അവസാനം. തിരിച്ചറിയൽ പരാജയപ്പെടുകയാണെങ്കിൽ, പൂജ്യം
തിരിച്ചെത്തി, * sp ചലിക്കില്ല.

int grok_infnan(const char** sp, const char *send)

ഗ്രോക്ക്_നമ്പർ
സമാനമാണ് grok_number_flags() പതാകകൾ പൂജ്യമായി സജ്ജീകരിച്ചിരിക്കുന്നു.

int grok_number(const char *pv, STRLEN ലെൻ,
UV * മൂല്യം)

grok_number_flags
ഒരു നമ്പർ തിരിച്ചറിയുക (അല്ലെങ്കിൽ ഇല്ല). സംഖ്യയുടെ തരം തിരികെ നൽകുന്നു (0 എങ്കിൽ
തിരിച്ചറിയാനാകാത്തത്), അല്ലാത്തപക്ഷം ഇത് IS_NUMBER_IN_UV യുടെ ബിറ്റ്-ഓർഡ് കോമ്പിനേഷനാണ്,
IS_NUMBER_GREATER_THAN_UV_MAX, IS_NUMBER_NOT_INT, IS_NUMBER_NEG,
IS_NUMBER_INFINITY, IS_NUMBER_NAN (perl.h-ൽ നിർവചിച്ചിരിക്കുന്നത്).

സംഖ്യയുടെ മൂല്യം ഒരു UV-യിൽ ഒതുങ്ങാൻ കഴിയുമെങ്കിൽ, അത് *വാല്യൂപ്പിൽ നൽകും
IS_NUMBER_IN_UV - മൂല്യം സാധുതയുള്ളതാണെന്ന് സൂചിപ്പിക്കാൻ സജ്ജീകരിക്കും, IS_NUMBER_IN_UV
* മൂല്യം സാധുതയുള്ളതല്ലാതെ ഒരിക്കലും സജ്ജീകരിക്കില്ല, എന്നാൽ * മൂല്യം നിയുക്തമാക്കിയിരിക്കാം
റിട്ടേണിൽ IS_NUMBER_IN_UV സജ്ജീകരിച്ചിട്ടില്ലെങ്കിലും പ്രോസസ്സിംഗ് സമയത്ത്. valuep ആണെങ്കിൽ
NULL, IS_NUMBER_IN_UV മൂല്യം NULL അല്ലാത്തപ്പോൾ അതേ കേസുകൾക്കായി സജ്ജീകരിക്കും,
എന്നാൽ യഥാർത്ഥ അസൈൻമെന്റ് (അല്ലെങ്കിൽ SEGV) സംഭവിക്കില്ല.

IS_NUMBER_NOT_INT എന്നതിനെ IS_NUMBER_IN_UV ഉപയോഗിച്ച് സജ്ജീകരിക്കും, പിന്നിലുള്ള ദശാംശങ്ങൾ കാണുകയാണെങ്കിൽ
(ഈ സാഹചര്യത്തിൽ *മൂല്യം ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് ചുരുക്കിയ യഥാർത്ഥ മൂല്യം നൽകുന്നു), കൂടാതെ
നമ്പർ നെഗറ്റീവ് ആണെങ്കിൽ IS_NUMBER_NEG (അങ്ങനെയെങ്കിൽ *മൂല്യം കേവലം പിടിക്കുന്നു
മൂല്യം). ഇ നൊട്ടേഷൻ ഉപയോഗിച്ചിരുന്നെങ്കിലോ സംഖ്യ വലുതാണെങ്കിൽ IS_NUMBER_IN_UV സജ്ജീകരിച്ചിട്ടില്ല
ഒരു യു.വി.

"ഫ്ലാഗുകൾ" "PERL_SCAN_TRAILING" മാത്രമേ അനുവദിക്കൂ, ഇത് അക്കങ്ങളല്ലാത്ത ട്രെയിലിംഗ് അനുവദിക്കുന്നു
അല്ലാത്തപക്ഷം വിജയിച്ചതിന്റെ വാചകം grok, ഫലത്തിൽ "IS_NUMBER_TRAILING" ക്രമീകരണം.

int grok_number_flags(const char *pv, STRLEN ലെൻ,
UV * മൂല്യം, U32 പതാകകൾ)

grok_numeric_radix
ഒരു ന്യൂമെറിക് ഡെസിമൽ സെപ്പറേറ്ററിനായി (റാഡിക്സ്) സ്കാൻ ചെയ്ത് ഒഴിവാക്കുക.

bool grok_numeric_radix(const char **sp,
കോൺസ്റ്റ് ചാർ *അയയ്‌ക്കുക)

grok_oct
ഒക്ടൽ സംഖ്യയെ പ്രതിനിധീകരിക്കുന്ന ഒരു സ്ട്രിംഗ് സംഖ്യാ രൂപത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു.

പ്രവേശന സമയത്ത് തുടക്കം ഒപ്പം *len സ്കാൻ ചെയ്യാൻ സ്ട്രിംഗ് നൽകുക, *പതാകകൾ പരിവർത്തന പതാകകൾ നൽകുന്നു,
ഒപ്പം ഫലം NULL അല്ലെങ്കിൽ NV-യിലേക്കുള്ള പോയിന്റർ ആയിരിക്കണം. സ്കാൻ അവസാനത്തോടെ നിർത്തുന്നു
സ്ട്രിംഗ്, അല്ലെങ്കിൽ ആദ്യത്തെ അസാധുവായ പ്രതീകം. "PERL_SCAN_SILENT_ILLDIGIT" സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ
in *പതാകകൾ, ഒരു 8 അല്ലെങ്കിൽ 9 കണ്ടുമുട്ടുന്നത് ഒരു മുന്നറിയിപ്പ് ട്രിഗർ ചെയ്യും. തിരികെ വരുമ്പോൾ *len is
സ്‌കാൻ ചെയ്‌ത സ്ട്രിംഗിന്റെ ദൈർഘ്യത്തിലേക്ക് സജ്ജമാക്കുക, ഒപ്പം *പതാകകൾ ഔട്ട്പുട്ട് ഫ്ലാഗുകൾ നൽകുന്നു.

മൂല്യം <= UV_MAX ആണെങ്കിൽ അത് UV ആയി നൽകും, ഔട്ട്‌പുട്ട് ഫ്ലാഗുകൾ വ്യക്തമാണ്, കൂടാതെ
ഒന്നും എഴുതിയിട്ടില്ല *ഫലമായി. മൂല്യം > UV_MAX ആണെങ്കിൽ "grok_oct" നൽകുന്നു
UV_MAX, ഔട്ട്‌പുട്ട് ഫ്ലാഗുകളിൽ "PERL_SCAN_GREATER_THAN_UV_MAX" സജ്ജീകരിക്കുകയും എഴുതുകയും ചെയ്യുന്നു
അതിന്റെ മൂല്യം *ഫലമായി (അല്ലെങ്കിൽ മൂല്യം ഉപേക്ഷിക്കപ്പെടും ഫലം NULL ആണ്).

"PERL_SCAN_ALLOW_UNDERSCORES" സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ *പതാകകൾ അപ്പോൾ ഒക്ടൽ നമ്പർ ഉപയോഗിക്കാം
അക്കങ്ങൾ വേർതിരിക്കുന്നതിനുള്ള '_' പ്രതീകങ്ങൾ.

UV grok_oct(const char* start, STRLEN* len_p,
I32* പതാകകൾ, NV *ഫലം)

isinfnan
Perl_isinfnan() NV ആർഗ്യുമെന്റ് ഒന്നാണെങ്കിൽ ശരിയാണെന്ന് നൽകുന്ന യൂട്ടിലിറ്റി ഫംഗ്‌ഷൻ ആണ്
ഒരു അനന്തത അല്ലെങ്കിൽ ഒരു NaN, അല്ലെങ്കിൽ തെറ്റ്. കൂടുതൽ വിശദമായി പരിശോധിക്കാൻ, ഉപയോഗിക്കുക Perl_isinf()
ഒപ്പം Perl_isnan().

ഇതും യുക്തിപരമായ വിപരീതമാണ് Perl_isfinite().

bool isinfnan (NV nv)

Perl_signbit
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു എൻവിയിലെ സൈൻ ബിറ്റ് സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ പൂജ്യമല്ലാത്ത ഒരു പൂർണ്ണസംഖ്യയും ഇല്ലെങ്കിൽ 0-ഉം നൽകുക.

കോൺഫിഗർ ചെയ്‌താൽ ഈ സിസ്റ്റത്തിന് ഒരു ഉണ്ട് signbit() അത് ഞങ്ങളുടെ NV-കൾക്കൊപ്പം പ്രവർത്തിക്കും
perl.h-ലെ #define വഴിയാണ് ഞങ്ങൾ ഇത് ഉപയോഗിക്കുന്നത്. അല്ലെങ്കിൽ, ഇതിൽ നിന്ന് പിന്തിരിയുക
നടപ്പിലാക്കൽ. ഈ ഫംഗ്ഷന്റെ പ്രധാന ഉപയോഗം ക്യാച്ചിംഗ് -0.0 ആണ്.

കുറിപ്പുകൾ കോൺഫിഗർ ചെയ്യുക: ഈ ഫംഗ്‌ഷനെ പ്ലെയിൻ എന്നതിന് പകരം 'Perl_signbit' എന്ന് വിളിക്കുന്നു
'signbit' കാരണം ഒരു സിസ്റ്റം ഉള്ളതായി സങ്കൽപ്പിക്കാൻ എളുപ്പമാണ് signbit() പ്രവർത്തനം അല്ലെങ്കിൽ
ഞങ്ങളുടെ പ്രത്യേക ചോയ്‌സ് എൻവികൾക്കൊപ്പം പ്രവർത്തിക്കാത്ത മാക്രോ. നമ്മൾ പാടില്ല
സൈൻബിറ്റിനെ Perl_signbit ആയി വീണ്ടും #നിർവചിക്കുകയും സ്റ്റാൻഡേർഡ് സിസ്റ്റം ഹെഡറുകൾ പ്രതീക്ഷിക്കുകയും ചെയ്യുക
സന്തോഷത്തിലായിരിക്കുക. കൂടാതെ, ഇതൊരു നോ-കണ്ടെക്സ്റ്റ് ഫംഗ്‌ഷനാണ് (pTHX_ ഇല്ല) കാരണം Perl_signbit()
സിസ്റ്റത്തിലേക്കുള്ള ഒരു ലളിതമായ മാക്രോ കോളായി perl.h-ൽ സാധാരണയായി വീണ്ടും # നിർവചിച്ചിരിക്കുന്നു signbit().
ഉപയോക്താക്കൾ എപ്പോഴും വിളിക്കണം Perl_signbit().

int Perl_signbit(NV f)

സ്കാൻ_ബിൻ
പിന്നോക്ക അനുയോജ്യതയ്ക്കായി. പകരം "grok_bin" ഉപയോഗിക്കുക.

NV scan_bin(const char* start, STRLEN ലെൻ,
STRLEN* retlen)

സ്കാൻ_ഹെക്സ്
പിന്നോക്ക അനുയോജ്യതയ്ക്കായി. പകരം "grok_hex" ഉപയോഗിക്കുക.

NV സ്കാൻ_ഹെക്സ്(കോൺസ്റ്റ് ചാർ* സ്റ്റാർട്ട്, STRLEN ലെൻ,
STRLEN* retlen)

സ്കാൻ_ഒക്ട്
പിന്നോക്ക അനുയോജ്യതയ്ക്കായി. പകരം "grok_oct" ഉപയോഗിക്കുക.

NV scan_oct(const char* start, STRLEN ലെൻ,
STRLEN* retlen)

കാലഹരണപ്പെട്ടു പിന്നിലേക്ക് അനുയോജ്യത ഫംഗ്ഷനുകളും

ഇവയിൽ ചിലത് ഒഴിവാക്കപ്പെട്ടതുമാണ്. നിങ്ങളുടെ സമാഹരിച്ച പേളിൽ നിന്ന് നിങ്ങൾക്ക് ഇവ ഒഴിവാക്കാനാകും
കോൺഫിഗർ ചെയ്യുന്നതിന് ഈ ഓപ്‌ഷൻ ചേർക്കുന്നു: "-Accflags='-DNO_MATHOMS'"

custom_op_desc
തന്നിരിക്കുന്ന ഇഷ്‌ടാനുസൃത ഓപ്പിന്റെ വിവരണം തിരികെ നൽകുക. ഇത് ഒരിക്കൽ OP_DESC ഉപയോഗിച്ചിരുന്നു
മാക്രോ, എന്നാൽ ഇനി ഇല്ല: ഇത് അനുയോജ്യതയ്ക്കായി മാത്രമാണ് സൂക്ഷിച്ചിരിക്കുന്നത്, പാടില്ല
ഉപയോഗിക്കും.

const char * custom_op_desc (const OP *o)

custom_op_name
തന്നിരിക്കുന്ന ഇഷ്‌ടാനുസൃത ഓപ്പിനായി പേര് തിരികെ നൽകുക. ഇത് ഒരിക്കൽ OP_NAME മാക്രോ ഉപയോഗിച്ചിരുന്നു,
എന്നാൽ മേലിൽ ഇല്ല: ഇത് അനുയോജ്യതയ്ക്കായി മാത്രം സൂക്ഷിച്ചിരിക്കുന്നു, ഉപയോഗിക്കാൻ പാടില്ല.

const char * custom_op_name(const OP *o)

gv_fetchmethod
"gv_fetchmethod_autoload" കാണുക.

GV* gv_fetchmethod(HV* സ്റ്റാഷ്, കോൺസ്റ്റ് ചാർ* പേര്)

is_utf8_char
ഒഴിവാക്കി! പേളിന്റെ ഭാവി റിലീസിൽ നിന്ന് ഈ ഫംഗ്‌ഷൻ നീക്കം ചെയ്യാൻ പദ്ധതിയിട്ടിട്ടുണ്ട്.
പുതിയ കോഡിനായി ഇത് ഉപയോഗിക്കരുത്; നിലവിലുള്ള കോഡിൽ നിന്ന് അത് നീക്കം ചെയ്യുക.

സാധുവായ UTF-8 പ്രതീകത്തിൽ ചില അനിയന്ത്രിതമായ ബൈറ്റുകൾ ആരംഭിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുന്നു. കുറിപ്പ്
ഒരു മാറ്റമില്ലാത്ത (അതായത് EBCDIC ഇതര മെഷീനുകളിലെ ASCII) പ്രതീകം സാധുവായ UTF-8 ആണ്
സ്വഭാവം. എങ്കിൽ UTF-8 പ്രതീകത്തിലെ യഥാർത്ഥ ബൈറ്റുകളുടെ എണ്ണം നൽകും
ഇത് സാധുവാണ്, അല്ലാത്തപക്ഷം 0.

തെറ്റായ ഇൻപുട്ടിന്റെ സാധ്യത കാരണം ഈ ഫംഗ്‌ഷൻ ഒഴിവാക്കിയിരിക്കുന്നു
ഇൻപുട്ട് ബഫറിന്റെ അവസാനത്തിനപ്പുറം വായനയ്ക്ക് കാരണമാകുന്നു. പകരം "isUTF8_CHAR" ഉപയോഗിക്കുക.

STRLEN is_utf8_char(const U8 *s)

is_utf8_char_buf
ഇത് മാക്രോ "isUTF8_CHAR" ന് സമാനമാണ്.

STRLEN is_utf8_char_buf(const U8 *buf,
const U8 *buf_end)

പാക്ക്_കാറ്റ്
എഞ്ചിൻ നടപ്പിലാക്കുന്നു പാക്ക് () പേൾ പ്രവർത്തനം. ശ്രദ്ധിക്കുക: പരാമീറ്ററുകൾ next_in_list ഒപ്പം
പതാകകൾ ഉപയോഗിക്കുന്നില്ല. ഈ കോൾ ഉപയോഗിക്കാൻ പാടില്ല; പകരം പാക്ക്‌ലിസ്റ്റ് ഉപയോഗിക്കുക.

void pack_cat(SV *cat, const char *pat,
const char *patend, SV **beglist,
SV ** endlist, SV ***next_in_list,
U32 പതാകകൾ)

pad_compname_type
സ്ഥാനത്ത് ലെക്സിക്കൽ വേരിയബിളിന്റെ തരം നോക്കുന്നു po നിലവിൽ-
കംപൈലിംഗ് പാഡ്. വേരിയബിൾ ടൈപ്പ് ചെയ്‌താൽ, അത് ഏത് ക്ലാസിലേക്കാണ് ഉള്ളത്
ടൈപ്പ് ചെയ്‌തത് തിരികെ ലഭിക്കുന്നു. ഇല്ലെങ്കിൽ, "NULL" തിരികെ നൽകും.

HV * pad_compname_type(PADOFFSET പോ)

sv_2pvbyte_nolen
SV-യുടെ ബൈറ്റ്-എൻകോഡ് ചെയ്ത പ്രാതിനിധ്യത്തിലേക്ക് ഒരു പോയിന്റർ തിരികെ നൽകുക. എസ്.വി.ക്ക് കാരണമാകാം
UTF-8-ൽ നിന്ന് ഒരു പാർശ്വഫലമായി തരംതാഴ്ത്തണം.

സാധാരണയായി "SvPVbyte_nolen" മാക്രോ വഴിയാണ് ആക്സസ് ചെയ്യുന്നത്.

char* sv_2pvbyte_nolen(SV* sv)

sv_2pvutf8_nolen
SV-യുടെ UTF-8-എൻകോഡ് ചെയ്ത പ്രാതിനിധ്യത്തിലേക്ക് ഒരു പോയിന്റർ തിരികെ നൽകുക. എസ്.വി.ക്ക് കാരണമാകാം
ഒരു പാർശ്വഫലമായി UTF-8 ലേക്ക് അപ്‌ഗ്രേഡ് ചെയ്യണം.

സാധാരണയായി "SvPVutf8_nolen" മാക്രോ വഴിയാണ് ആക്സസ് ചെയ്യുന്നത്.

char* sv_2pvutf8_nolen(SV* sv)

sv_2pv_nolen
"sv_2pv()" പോലെ, എന്നാൽ ദൈർഘ്യവും നൽകുന്നില്ല. നിങ്ങൾ സാധാരണയായി ഉപയോഗിക്കണം
പകരം "SvPV_nolen(sv)" മാക്രോ റാപ്പർ.

char* sv_2pv_nolen(SV* sv)

sv_catpvn_mg
"sv_catpvn" പോലെ, എന്നാൽ 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു.

void sv_catpvn_mg(SV *sv, const char *ptr,
STRLEN ലെൻ)

sv_catsv_mg
"sv_catsv" പോലെ, മാത്രമല്ല 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു.

ശൂന്യമായ sv_catsv_mg(SV *dsv, SV *ssv)

sv_force_normal
ഒരു SV-യിൽ വിവിധ തരത്തിലുള്ള വ്യാജങ്ങൾ പഴയപടിയാക്കുക: PV ഒരു പങ്കിട്ട സ്ട്രിംഗ് ആണെങ്കിൽ, a ഉണ്ടാക്കുക
സ്വകാര്യ പകർപ്പ്; ഞങ്ങൾ ഒരു റഫർ ആണെങ്കിൽ, റഫിംഗ് നിർത്തുക; നമ്മൾ ഒരു ഗ്ലോബ് ആണെങ്കിൽ, ഒരു xpvmg ലേക്ക് ഡൗൺഗ്രേഡ് ചെയ്യുക.
"sv_force_normal_flags" എന്നതും കാണുക.

അസാധുവായ sv_force_normal(SV *sv)

sv_iv നേരിടാൻ കഴിയാത്ത കംപൈലറുകൾക്കായി "SvIVx" മാക്രോയുടെ ഒരു സ്വകാര്യ നിർവ്വഹണം
സങ്കീർണ്ണമായ മാക്രോ എക്സ്പ്രഷനുകൾ. പകരം എപ്പോഴും മാക്രോ ഉപയോഗിക്കുക.

IV sv_iv(SV* sv)

sv_nolocking
ലോക്കിംഗ് മൊഡ്യൂൾ ഇല്ലാതിരിക്കുമ്പോൾ ഒരു SV "ലോക്ക്" ചെയ്യുന്ന ഡമ്മി ദിനചര്യ. നിലവിലുണ്ട്
NULL ഫംഗ്‌ഷൻ പോയിന്ററിനായുള്ള പരിശോധന ഒഴിവാക്കാനും അത് മുന്നറിയിപ്പ് നൽകാനും സാധ്യതയുണ്ട്
കർശനമായ ചില തലങ്ങളിൽ.

"സൂപ്പർസെഡ്" ചെയ്തത് sv_nosharing().

അസാധുവായ sv_nolocking(SV *sv)

sv_nounlocking
ലോക്കിംഗ് മൊഡ്യൂൾ നിലവിലില്ലാത്തപ്പോൾ ഒരു SV "അൺലോക്ക്" ചെയ്യുന്ന ഡമ്മി ദിനചര്യ.
ഒരു NULL ഫംഗ്‌ഷൻ പോയിന്ററിനായുള്ള പരിശോധന ഒഴിവാക്കാനും അതിന് സാധ്യതയുള്ളതിനാലും നിലവിലുണ്ട്
കർശനമായ ചില തലങ്ങളിൽ മുന്നറിയിപ്പ് നൽകുക.

"സൂപ്പർസെഡ്" ചെയ്തത് sv_nosharing().

അസാധുവായ sv_nounlocking(SV *sv)

sv_nv കംപൈലറുകൾക്ക് നേരിടാൻ കഴിയാത്ത "SvNVx" മാക്രോയുടെ ഒരു സ്വകാര്യ നിർവ്വഹണം
സങ്കീർണ്ണമായ മാക്രോ എക്സ്പ്രഷനുകൾ. പകരം എപ്പോഴും മാക്രോ ഉപയോഗിക്കുക.

NV sv_nv(SV* sv)

sv_pv പകരം "SvPV_nolen" മാക്രോ ഉപയോഗിക്കുക

char* sv_pv(SV *sv)

sv_pvbyte
പകരം "SvPVbyte_nolen" ഉപയോഗിക്കുക.

char* sv_pvbyte(SV *sv)

sv_pvbyten
നേരിടാൻ കഴിയാത്ത കംപൈലറുകൾക്കായി "SvPVbyte" മാക്രോയുടെ സ്വകാര്യ നിർവ്വഹണം
സങ്കീർണ്ണമായ മാക്രോ എക്സ്പ്രഷനുകൾക്കൊപ്പം. പകരം എപ്പോഴും മാക്രോ ഉപയോഗിക്കുക.

char* sv_pvbyten(SV *sv, STRLEN *lp)

sv_pvn കംപൈലറുകൾക്ക് നേരിടാൻ കഴിയാത്ത "SvPV" മാക്രോയുടെ ഒരു സ്വകാര്യ നിർവ്വഹണം
സങ്കീർണ്ണമായ മാക്രോ എക്സ്പ്രഷനുകൾ. പകരം എപ്പോഴും മാക്രോ ഉപയോഗിക്കുക.

char* sv_pvn(SV *sv, STRLEN *lp)

sv_pvutf8
പകരം "SvPVutf8_nolen" മാക്രോ ഉപയോഗിക്കുക

char* sv_pvutf8(SV *sv)

sv_pvutf8n
നേരിടാൻ കഴിയാത്ത കംപൈലറുകൾക്കായി "SvPVutf8" മാക്രോയുടെ ഒരു സ്വകാര്യ നിർവ്വഹണം
സങ്കീർണ്ണമായ മാക്രോ എക്സ്പ്രഷനുകൾക്കൊപ്പം. പകരം എപ്പോഴും മാക്രോ ഉപയോഗിക്കുക.

char* sv_pvutf8n(SV *sv, STRLEN *lp)

sv_taint
ഒരു എസ്വിയെ കളങ്കപ്പെടുത്തുക. പകരം "SvTAINTED_on" ഉപയോഗിക്കുക.

അസാധുവായ sv_taint(SV* sv)

sv_unref
SV-യുടെ RV സ്റ്റാറ്റസ് അൺസെറ്റ് ചെയ്യുന്നു, കൂടാതെ എന്തായിരുന്നാലും അതിന്റെ റഫറൻസ് എണ്ണം കുറയ്ക്കുന്നു
RV പരാമർശിക്കുന്നു. ഇത് ഏതാണ്ട് വിപരീതമായി കണക്കാക്കാം
"newSVrv". ഇത് "sv_unref_flags" ആണ്, "ഫ്ലാഗ്" പൂജ്യമാണ്. "SvROK_off" കാണുക.

അസാധുവായ sv_unref(SV* sv)

sv_usepvn
ഒരു എസ്വിയോട് അതിന്റെ സ്ട്രിംഗ് മൂല്യം കണ്ടെത്താൻ "ptr" ഉപയോഗിക്കാൻ പറയുന്നു. വിളിച്ച് നടപ്പിലാക്കിയത്
0 ന്റെ "ഫ്ലാഗുകൾ" ഉള്ള "sv_usepvn_flags", അതിനാൽ 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നില്ല. കാണുക
"sv_usepvn_flags".

void sv_usepvn(SV* sv, char* ptr, STRLEN ലെൻ)

sv_usepvn_mg
"sv_usepvn" പോലെ, മാത്രമല്ല 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു.

void sv_usepvn_mg(SV *sv, char *ptr, STRLEN ലെൻ)

sv_uv കംപൈലറുകൾക്ക് നേരിടാൻ കഴിയാത്ത "SvUVx" മാക്രോയുടെ ഒരു സ്വകാര്യ നിർവ്വഹണം
സങ്കീർണ്ണമായ മാക്രോ എക്സ്പ്രഷനുകൾ. പകരം എപ്പോഴും മാക്രോ ഉപയോഗിക്കുക.

UV sv_uv(SV* sv)

അൺപാക്ക്_str
എഞ്ചിൻ നടപ്പിലാക്കുന്നു അൺപാക്ക്() പേൾ പ്രവർത്തനം. ശ്രദ്ധിക്കുക: പരാമീറ്ററുകൾ strbeg, new_s
ocnt എന്നിവ ഉപയോഗിക്കുന്നില്ല. ഈ കോൾ ഉപയോഗിക്കാൻ പാടില്ല, പകരം അൺപാക്ക്‌സ്ട്രിംഗ് ഉപയോഗിക്കുക.

I32 unpack_str(const char *pat, const char *patend,
const char *s, const char *strbeg,
കോൺസ്റ്റ് ചാർ *സ്ട്രെൻഡ്, ചാർ **പുതിയ_കൾ,
I32 ocnt, U32 പതാകകൾ)

utf8_to_uvchr
ഒഴിവാക്കി! പേളിന്റെ ഭാവി റിലീസിൽ നിന്ന് ഈ ഫംഗ്‌ഷൻ നീക്കം ചെയ്യാൻ പദ്ധതിയിട്ടിട്ടുണ്ട്.
പുതിയ കോഡിനായി ഇത് ഉപയോഗിക്കരുത്; നിലവിലുള്ള കോഡിൽ നിന്ന് അത് നീക്കം ചെയ്യുക.

"s" എന്ന സ്ട്രിംഗിലെ ആദ്യ പ്രതീകത്തിന്റെ നേറ്റീവ് കോഡ് പോയിന്റ് നൽകുന്നു
UTF-8 എൻകോഡിംഗിലാണെന്ന് അനുമാനിക്കുന്നു; "retlen" ന്റെ നീളം, ബൈറ്റുകളിൽ സജ്ജീകരിക്കും
ആ കഥാപാത്രം.

ചിലത്, എന്നാൽ എല്ലാം അല്ല, UTF-8 തകരാറുകൾ കണ്ടെത്തി, വാസ്തവത്തിൽ, ചിലത് വികലമാണ്
ഇൻപുട്ട് ബഫറിന്റെ അവസാനത്തിനപ്പുറം വായനയ്ക്ക് കാരണമായേക്കാം, അതിനാലാണ് ഇത്
പ്രവർത്തനം അവസാനിപ്പിച്ചു. പകരം "utf8_to_uvchr_buf" ഉപയോഗിക്കുക.

"s" കണ്ടെത്തിയ തകരാറുകളിലൊന്നിലേക്ക് വിരൽ ചൂണ്ടുകയും UTF8 മുന്നറിയിപ്പുകൾ പ്രവർത്തനക്ഷമമാക്കുകയും ചെയ്താൽ,
പൂജ്യം തിരികെ നൽകുകയും *retlen സജ്ജീകരിക്കുകയും ചെയ്യുന്നു ("retlen" NULL അല്ലെങ്കിൽ) -1 ആയി. എങ്കിൽ അവ
മുന്നറിയിപ്പുകൾ ഓഫാണ്, നന്നായി നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ കണക്കുകൂട്ടിയ മൂല്യം (അല്ലെങ്കിൽ യൂണികോഡ് മാറ്റിസ്ഥാപിക്കൽ
CHARACTER, ഇല്ലെങ്കിൽ) നിശബ്‌ദമായി തിരികെ നൽകി, *retlen സജ്ജീകരിച്ചിരിക്കുന്നു ("retlen" അല്ലെങ്കിൽ
NULL) അതിനാൽ ("s" + *retlen) എന്നത് "s"-ൽ സാധ്യമായ അടുത്ത സ്ഥാനമാണ്
വികലമല്ലാത്ത ഒരു പ്രതീകം ആരംഭിക്കുക. എപ്പോൾ എന്നതിനെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾക്ക് "utf8n_to_uvchr" കാണുക
മാറ്റിസ്ഥാപിക്കൽ പ്രതീകം തിരികെ നൽകി.

UV utf8_to_uvchr(const U8 *s, STRLEN *retlen)

utf8_to_uvuni
ഒഴിവാക്കി! പേളിന്റെ ഭാവി റിലീസിൽ നിന്ന് ഈ ഫംഗ്‌ഷൻ നീക്കം ചെയ്യാൻ പദ്ധതിയിട്ടിട്ടുണ്ട്.
പുതിയ കോഡിനായി ഇത് ഉപയോഗിക്കരുത്; നിലവിലുള്ള കോഡിൽ നിന്ന് അത് നീക്കം ചെയ്യുക.

"s" എന്ന സ്ട്രിംഗിലെ ആദ്യ പ്രതീകത്തിന്റെ യൂണികോഡ് കോഡ് പോയിന്റ് നൽകുന്നു
UTF-8 എൻകോഡിംഗിലാണെന്ന് അനുമാനിക്കുന്നു; "retlen" ന്റെ നീളം, ബൈറ്റുകളിൽ സജ്ജീകരിക്കും
ആ കഥാപാത്രം.

ചിലത്, എന്നാൽ എല്ലാം അല്ല, UTF-8 തകരാറുകൾ കണ്ടെത്തി, വാസ്തവത്തിൽ, ചിലത് വികലമാണ്
ഇൻപുട്ട് ബഫറിന്റെ അവസാനത്തിനപ്പുറം വായനയ്ക്ക് കാരണമായേക്കാം, ഇത് ഒരു കാരണമാണ്
എന്തുകൊണ്ടാണ് ഈ പ്രവർത്തനം ഒഴിവാക്കിയത്. മറ്റൊന്ന് വളരെ പരിമിതമായ അളവിൽ മാത്രം
സാഹചര്യങ്ങൾ യൂണികോഡും നേറ്റീവ് കോഡ് പോയിന്റും താൽപ്പര്യമുള്ളതായിരിക്കണം
നിങ്ങൾ. ഇതരമാർഗ്ഗങ്ങൾക്കായി "utf8_to_uvuni_buf" കാണുക.

"s" കണ്ടെത്തിയ തകരാറുകളിലൊന്നിലേക്ക് വിരൽ ചൂണ്ടുകയും UTF8 മുന്നറിയിപ്പുകൾ പ്രവർത്തനക്ഷമമാക്കുകയും ചെയ്താൽ,
പൂജ്യം തിരികെ നൽകുകയും *retlen സജ്ജീകരിക്കുകയും ചെയ്യുന്നു ("retlen" NULL ലേക്ക് പോയിന്റ് ചെയ്യുന്നില്ലെങ്കിൽ) -1 ആയി. എങ്കിൽ
ആ മുന്നറിയിപ്പുകൾ ഓഫാണ്, നന്നായി നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ (അല്ലെങ്കിൽ യൂണികോഡ്) കണക്കാക്കിയ മൂല്യം
മാറ്റിസ്ഥാപിക്കൽ പ്രതീകം, ഇല്ലെങ്കിൽ) നിശബ്ദമായി തിരികെ നൽകുകയും *retlen സജ്ജീകരിക്കുകയും ചെയ്യുന്നു (എങ്കിൽ
"retlen" NULL അല്ല) അതിനാൽ ("s" + *retlen) ആണ് "s" ലെ അടുത്ത സാധ്യമായ സ്ഥാനം
അതൊരു വികലമായ സ്വഭാവം ആരംഭിക്കും. വിശദാംശങ്ങൾക്ക് "utf8n_to_uvchr" കാണുക
REPLACEMENT CHARACTER തിരികെ നൽകുമ്പോൾ.

UV utf8_to_uvuni(const U8 *s, STRLEN *retlen)

ഒപ്ട്രീ നിര്മ്മാണം

പുതിയ ASSIGNOP
ഒരു അസൈൻമെന്റ് ഓപ്പ് നിർമ്മിക്കുകയും പരിശോധിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു. ഇടത്തെ ഒപ്പം വലത് വിതരണം ചെയ്യുക
അസൈൻമെന്റിന്റെ പാരാമീറ്ററുകൾ; അവ ഈ പ്രവർത്തനത്താൽ ദഹിപ്പിക്കപ്പെടുകയും ഭാഗമാവുകയും ചെയ്യുന്നു
നിർമ്മിച്ച ഓപ് ട്രീയുടെ.

If ഒപ്ടൈപ്പ് "OP_ANDASSIGN", "OP_ORASSIGN", അല്ലെങ്കിൽ "OP_DORASSIGN", തുടർന്ന് അനുയോജ്യമാണ്
സോപാധിക ഒപ്ട്രീ നിർമ്മിച്ചിരിക്കുന്നു. എങ്കിൽ ഒപ്ടൈപ്പ് ഒരു ബൈനറി ഓപ്പറേറ്ററുടെ ഒപ്‌കോഡാണ്,
"OP_BIT_OR" പോലെ, ബൈനറി ഓപ്പറേഷൻ നടത്തുന്ന ഒരു op നിർമ്മിക്കപ്പെടുന്നു
ഇടത് ആർഗ്യുമെന്റിലേക്ക് ഫലം നൽകുകയും ചെയ്യുന്നു. ഒന്നുകിൽ, എങ്കിൽ ഒപ്ടൈപ്പ് പൂജ്യമല്ല
അപ്പോള് ഫ്ലാഗുകൾ ഒരു ഫലവുമില്ല.

If ഒപ്ടൈപ്പ് പൂജ്യമാണ്, തുടർന്ന് ഒരു പ്ലെയിൻ സ്കെയിലർ അല്ലെങ്കിൽ ലിസ്റ്റ് അസൈൻമെന്റ് നിർമ്മിക്കുന്നു. ഏത്
അസൈൻമെന്റിന്റെ തരം സ്വയമേവ നിർണ്ണയിക്കപ്പെടുന്നു. ഫ്ലാഗുകൾ എട്ട് ബിറ്റുകൾ നൽകുന്നു
"op_flags" എന്നതിന്റെ, "OPf_KIDS" സ്വയമേവ സജ്ജീകരിക്കും, കൂടാതെ, മുകളിലേക്ക് മാറ്റും
എട്ട് ബിറ്റുകൾ, "op_private" എന്നതിന്റെ എട്ട് ബിറ്റുകൾ, മൂല്യം 1 അല്ലെങ്കിൽ 2 ഉള്ള ബിറ്റ് ഒഴികെ
ആവശ്യാനുസരണം സ്വയമേവ സജ്ജീകരിച്ചിരിക്കുന്നു.

OP * newASSIGNOP(I32 ഫ്ലാഗുകൾ, OP *ഇടത്, I32 ഒപ്‌ടൈപ്പ്,
OP *വലത്)

പുതിയ ബിനോപ്
ഏത് ബൈനറി തരത്തിലുമുള്ള ഒരു OP നിർമ്മിക്കുകയും പരിശോധിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു. ടൈപ്പ് ചെയ്യുക ഒപ്കോഡ് ആണ്.
ഫ്ലാഗുകൾ എട്ട് ബിറ്റുകൾ "op_flags" നൽകുന്നു, അല്ലാതെ "OPf_KIDS" സജ്ജീകരിക്കും
സ്വയമേവ, കൂടാതെ, "op_private" എന്നതിന്റെ എട്ട് ബിറ്റുകൾ, എട്ട് ബിറ്റുകൾ മുകളിലേക്ക് മാറ്റി
മൂല്യം 1 അല്ലെങ്കിൽ 2 ഉള്ള ബിറ്റ് ആവശ്യാനുസരണം സ്വയമേവ സജ്ജീകരിച്ചിരിക്കുന്നു. ആദ്യം ഒപ്പം അവസാനത്തെ
ബൈനറി ഓപ്പിന്റെ നേരിട്ടുള്ള കുട്ടികളാകാൻ രണ്ട് ഓപ്‌സ് വരെ വിതരണം ചെയ്യുക; അവ ദഹിപ്പിക്കപ്പെടുന്നു
ഈ പ്രവർത്തനത്തിലൂടെ നിർമ്മിച്ച ഓപ് ട്രീയുടെ ഭാഗമാകുക.

OP * newBINOP(I32 തരം, I32 ഫ്ലാഗുകൾ, OP *ആദ്യം,
ഒപി *അവസാനം)

പുതിയCONDOP
ഒരു സോപാധിക-എക്‌സ്‌പ്രഷൻ ("cond_expr") OP നിർമ്മിക്കുകയും പരിശോധിക്കുകയും നൽകുകയും ചെയ്യുന്നു. ഫ്ലാഗുകൾ
എട്ട് ബിറ്റുകൾ "op_flags" നൽകുന്നു, അല്ലാതെ "OPf_KIDS" സജ്ജീകരിക്കും
സ്വയമേവ, കൂടാതെ, "op_private" എന്നതിന്റെ എട്ട് ബിറ്റുകൾ, എട്ട് ബിറ്റുകൾ മുകളിലേക്ക് മാറ്റി
മൂല്യം 1 ഉള്ള ബിറ്റ് സ്വയമേവ സജ്ജീകരിച്ചിരിക്കുന്നു. ആദ്യം എക്സ്പ്രഷൻ നൽകുന്നു
രണ്ട് ശാഖകൾക്കിടയിൽ തിരഞ്ഞെടുക്കൽ, കൂടാതെ trueop ഒപ്പം കള്ളം ശാഖകൾ വിതരണം ചെയ്യുക;
അവ ഈ പ്രവർത്തനത്താൽ ദഹിപ്പിക്കപ്പെടുകയും നിർമ്മിച്ച ഓപ് ട്രീയുടെ ഭാഗമാവുകയും ചെയ്യുന്നു.

OP * newCONDOP(I32 ഫ്ലാഗുകൾ, OP *ആദ്യം, OP *trueop,
OP *തെറ്റ്)

പുതിയ DEFSVOP
ഒരു ലെക്സിക്കൽ വേരിയബിളായി ഒന്നുകിൽ $_ ആക്സസ് ചെയ്യുന്നതിനായി ഒരു ഓപ് നിർമ്മിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു (എങ്കിൽ
നിലവിലെ സ്കോപ്പിൽ "എന്റെ $_") അല്ലെങ്കിൽ ആഗോള $_ ആയി പ്രഖ്യാപിച്ചു.

OP * newDEFSVOP()

പുതിയFOROP
"ഫോറച്ച്" ലൂപ്പ് (ആവർത്തനം) പ്രകടിപ്പിക്കുന്ന ഒരു ഓപ് ട്രീ നിർമ്മിക്കുകയും പരിശോധിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു
മൂല്യങ്ങളുടെ പട്ടികയിലൂടെ). ഇത് ഒരു ഹെവിവെയ്റ്റ് ലൂപ്പാണ്, ഇത് അനുവദിക്കുന്ന ഘടനയാണ്
ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കുന്നത് "അവസാനവും"

sv ഓപ്ഷണലായി ഓരോ ഇനത്തിനും അപരനാമമായ വേരിയബിൾ നൽകുന്നു; എങ്കിൽ
null, ഇത് $_ ലേക്ക് ഡിഫോൾട്ട് ചെയ്യുന്നു (ലെക്സിക്കൽ അല്ലെങ്കിൽ ഗ്ലോബൽ ഒന്നുകിൽ). exr യുടെ ലിസ്റ്റ് നൽകുന്നു
ആവർത്തിക്കാനുള്ള മൂല്യങ്ങൾ. ബ്ലോക്ക് ലൂപ്പിന്റെ പ്രധാന ഭാഗം വിതരണം ചെയ്യുന്നു, കൂടാതെ കണ്ടം
ഓപ്ഷണലായി ശരീരത്തിന്റെ രണ്ടാം പകുതിയായി പ്രവർത്തിക്കുന്ന ഒരു "തുടരുക" ബ്ലോക്ക് നൽകുന്നു.
ഈ ഒപ്‌ട്രീ ഇൻപുട്ടുകളെല്ലാം ഈ ഫംഗ്‌ഷൻ ഉപയോഗിക്കുകയും അതിന്റെ ഭാഗമാവുകയും ചെയ്യുന്നു
ഓപ് ട്രീ നിർമ്മിച്ചു.

ഫ്ലാഗുകൾ "leaveloop" op-ന് വേണ്ടി "op_flags" ന്റെ എട്ട് ബിറ്റുകൾ നൽകുന്നു, ഒപ്പം ഷിഫ്റ്റ് അപ്പ്
എട്ട് ബിറ്റുകൾ, "leaveloop" op-നുള്ള "op_private" ന്റെ എട്ട് ബിറ്റുകൾ, അതല്ലാതെ (ഇൻ
രണ്ട് സന്ദർഭങ്ങളിലും) ചില ബിറ്റുകൾ സ്വയമേവ സജ്ജീകരിക്കും.

OP * newFOROP(I32 ഫ്ലാഗുകൾ, OP *sv, OP *expr, OP *ബ്ലോക്ക്,
OP *തുടർച്ച)

പുതിയ GIVENOP
"നൽകിയ" ബ്ലോക്ക് പ്രകടിപ്പിക്കുന്ന ഒരു ഓപ് ട്രീ നിർമ്മിക്കുകയും പരിശോധിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു. അവസ്ഥ
ഒരു ലെക്സിക്കൽ വേരിയബിളിന് പ്രാദേശികമായി അസൈൻ ചെയ്യപ്പെടുന്ന പദപ്രയോഗം നൽകുന്നു, കൂടാതെ
ബ്ലോക്ക് "നൽകിയ" നിർമ്മിതിയുടെ ശരീരം നൽകുന്നു; അവർ ഇതുമൂലം ദഹിപ്പിക്കപ്പെടുന്നു
പ്രവർത്തിക്കുകയും നിർമ്മിച്ച ഓപ് ട്രീയുടെ ഭാഗമാവുകയും ചെയ്യുക. defsv_off പാഡ് ഓഫ്സെറ്റ് ആണ്
സ്കെയിലർ ലെക്സിക്കൽ വേരിയബിളിനെ ബാധിക്കും. ഇത് 0 ആണെങ്കിൽ, ആഗോള $_
ഉപയോഗിക്കും.

OP * newGIVENOP(OP *cond, OP *ബ്ലോക്ക്,
PADOFFSET defsv_off)

newGVOP ഒരു എംബഡഡ് ഉൾപ്പെടുന്ന ഏതെങ്കിലും തരത്തിലുള്ള ഒരു OP നിർമ്മിക്കുകയും പരിശോധിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു
ഒരു ജിവിയെക്കുറിച്ചുള്ള പരാമർശം. ടൈപ്പ് ചെയ്യുക ഒപ്കോഡ് ആണ്. ഫ്ലാഗുകൾ "op_flags" എട്ട് ബിറ്റുകൾ നൽകുന്നു.
gv op റഫറൻസ് ചെയ്യേണ്ട ജിവിയെ തിരിച്ചറിയുന്നു; ഈ ഫംഗ്‌ഷൻ വിളിക്കുന്നത് അങ്ങനെയല്ല
അതിലേക്കുള്ള ഏതെങ്കിലും റഫറൻസിന്റെ ഉടമസ്ഥാവകാശം കൈമാറുക.

OP * newGVOP(I32 തരം, I32 ഫ്ലാഗുകൾ, GV *gv)

പുതിയ ലിസ്റ്റോപ്പ്
ഏത് തരത്തിലുള്ള ലിസ്റ്റ് തരത്തിലുമുള്ള ഒരു ഓപ് നിർമ്മിക്കുകയും പരിശോധിക്കുകയും നൽകുകയും ചെയ്യുന്നു. ടൈപ്പ് ചെയ്യുക ഒപ്കോഡ് ആണ്.
ഫ്ലാഗുകൾ എട്ട് ബിറ്റുകൾ "op_flags" നൽകുന്നു, അല്ലാതെ "OPf_KIDS" സജ്ജീകരിക്കും
ആവശ്യമെങ്കിൽ സ്വയമേവ. ആദ്യം ഒപ്പം അവസാനത്തെ നേരിട്ടുള്ള രണ്ട് ഓപ്‌സ് വരെ വിതരണം ചെയ്യുക
ലിസ്റ്റിലെ കുട്ടികൾ; അവ ഈ പ്രവർത്തനത്താൽ ദഹിപ്പിക്കപ്പെടുകയും അതിന്റെ ഭാഗമാവുകയും ചെയ്യുന്നു
ഓപ് ട്രീ നിർമ്മിച്ചു.

മിക്ക ലിസ്റ്റ് ഓപ്പറേറ്റർമാർക്കും, ചെക്ക് ഫംഗ്‌ഷൻ എല്ലാ കിഡ് ഓപ്പുകളും ഉണ്ടായിരിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നു
ഇതിനകം, അതിനാൽ "newLISTOP(OP_JOIN, ...)" (ഉദാ) എന്ന് വിളിക്കുന്നത് ഉചിതമല്ല. നീ എന്താ
അങ്ങനെയെങ്കിൽ ചെയ്യേണ്ടത് OP_LIST എന്ന തരത്തിലുള്ള ഒരു OP സൃഷ്ടിക്കുക, കൂടുതൽ കുട്ടികളെ കൂട്ടിച്ചേർക്കുക എന്നതാണ്
അത്, തുടർന്ന് "op_convert_list" എന്ന് വിളിക്കുക. കൂടുതൽ വിവരങ്ങൾക്ക് "op_convert_list" കാണുക.

OP * newLISTOP(I32 തരം, I32 ഫ്ലാഗുകൾ, OP *ആദ്യം,
ഒപി *അവസാനം)

പുതിയ LOGOP
ഒരു ലോജിക്കൽ (ഫ്ലോ കൺട്രോൾ) ഓപ് നിർമ്മിക്കുകയും പരിശോധിക്കുകയും നൽകുകയും ചെയ്യുന്നു. ടൈപ്പ് ചെയ്യുക ഒപ്കോഡ് ആണ്.
ഫ്ലാഗുകൾ എട്ട് ബിറ്റുകൾ "op_flags" നൽകുന്നു, അല്ലാതെ "OPf_KIDS" സജ്ജീകരിക്കും
സ്വയമേവ, കൂടാതെ, "op_private" എന്നതിന്റെ എട്ട് ബിറ്റുകൾ, എട്ട് ബിറ്റുകൾ മുകളിലേക്ക് മാറ്റി
മൂല്യം 1 ഉള്ള ബിറ്റ് സ്വയമേവ സജ്ജീകരിച്ചിരിക്കുന്നു. ആദ്യം എക്സ്പ്രഷൻ നൽകുന്നു
ഒഴുക്ക് നിയന്ത്രിക്കൽ, ഒപ്പം മറ്റ് ഓപ്‌സിന്റെ സൈഡ് (ഇതര) ശൃംഖല വിതരണം ചെയ്യുന്നു; അവർ
ഈ ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് ദഹിപ്പിക്കപ്പെടുകയും നിർമ്മിച്ച ഓപ് ട്രീയുടെ ഭാഗമാവുകയും ചെയ്യുന്നു.

OP * newLOGOP(I32 തരം, I32 ഫ്ലാഗുകൾ, OP *ആദ്യം,
OP *മറ്റ്)

newLOOPEX
ഒരു ലൂപ്പ്-എക്‌സിറ്റിംഗ് ഓപ് ("ഗോട്ടോ" അല്ലെങ്കിൽ "ലാസ്റ്റ്" പോലുള്ളവ) നിർമ്മിക്കുകയും പരിശോധിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു.
ടൈപ്പ് ചെയ്യുക ഒപ്കോഡ് ആണ്. ലേബൽ എന്നതിന്റെ ലക്ഷ്യം നിർണ്ണയിക്കുന്ന പരാമീറ്റർ നൽകുന്നു
ഒപി; ഇത് ഈ ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് ദഹിപ്പിക്കപ്പെടുകയും നിർമ്മിച്ച ഓപ് ട്രീയുടെ ഭാഗമാവുകയും ചെയ്യുന്നു.

OP * newLOOPEX(I32 തരം, OP *ലേബൽ)

newLOOPOP
ഒരു ലൂപ്പ് പ്രകടിപ്പിക്കുന്ന ഒരു ഓപ് ട്രീ നിർമ്മിക്കുകയും പരിശോധിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു. ഇതൊരു ലൂപ്പ് മാത്രമാണ്
ഓപ് ട്രീയിലൂടെയുള്ള നിയന്ത്രണ പ്രവാഹത്തിൽ; അതിന് ഹെവിവെയ്റ്റ് ലൂപ്പ് ഇല്ല
ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കാൻ അനുവദിക്കുന്ന ഘടന ഫ്ലാഗുകൾ നൽകുന്നു
ടോപ്പ് ലെവൽ ഓപ്പിനായി "op_flags" എട്ട് ബിറ്റുകൾ, ചില ബിറ്റുകൾ സജ്ജീകരിക്കും എന്നതൊഴിച്ചാൽ
ആവശ്യാനുസരണം സ്വയമേവ. exr എക്സ്പ്രഷൻ കൺട്രോളിംഗ് ലൂപ്പ് നൽകുന്നു
ആവർത്തനം, ഒപ്പം ബ്ലോക്ക് ലൂപ്പിന്റെ ശരീരം നൽകുന്നു; അവർ ഇതുമൂലം ദഹിപ്പിക്കപ്പെടുന്നു
പ്രവർത്തിക്കുകയും നിർമ്മിച്ച ഓപ് ട്രീയുടെ ഭാഗമാവുകയും ചെയ്യുക. ഡീബഗ്ഗ് ചെയ്യാവുന്ന നിലവിൽ
ഉപയോഗിക്കാത്തതും എല്ലായ്പ്പോഴും 1 ആയിരിക്കണം.

OP * newLOOPOP(I32 ഫ്ലാഗുകൾ, I32 ഡീബഗ്ഗബിൾ, OP *expr,
OP *ബ്ലോക്ക്)

പുതിയ രീതി
ഒരു രീതിയുടെ പേര് മൂല്യനിർണ്ണയം ചെയ്‌ത രീതിയിലുള്ള ഒരു ഓപ്‌സ് നിർമ്മിക്കുകയും പരിശോധിക്കുകയും നൽകുകയും ചെയ്യുന്നു
റൺടൈമിൽ. ടൈപ്പ് ചെയ്യുക ഒപ്കോഡ് ആണ്. ഫ്ലാഗുകൾ ഒഴികെ "op_flags" എട്ട് ബിറ്റുകൾ നൽകുന്നു
"OPf_KIDS" സ്വയമേവ സജ്ജീകരിക്കും, കൂടാതെ എട്ട് ബിറ്റുകൾ മുകളിലേക്ക് മാറ്റി, എട്ട്
"op_private" എന്നതിന്റെ ബിറ്റുകൾ, മൂല്യം 1 ഉള്ള ബിറ്റ് സ്വയമേവ സജ്ജീകരിച്ചിരിക്കുന്നു എന്നതൊഴിച്ചാൽ.
ഡൈനാമിക്_മെത്ത് രീതിയുടെ പേര് വിലയിരുത്തുന്ന ഒരു op നൽകുന്നു; ഇത് ദഹിപ്പിക്കപ്പെടുന്നു
പ്രവർത്തിക്കുകയും നിർമ്മിച്ച ഓപ് ട്രീയുടെ ഭാഗമാവുകയും ചെയ്യുക. പിന്തുണയ്ക്കുന്ന ഒപ്‌ടൈപ്പുകൾ:
OP_METHOD.

OP * newMETHOP(I32 തരം, I32 ഫ്ലാഗുകൾ, OP *ആദ്യം)

പുതിയ METHOP_named
സ്ഥിരമായ ഒരു രീതി നാമമുള്ള രീതിയുടെ ഒരു ഓപ് നിർമ്മിക്കുകയും പരിശോധിക്കുകയും നൽകുകയും ചെയ്യുന്നു.
ടൈപ്പ് ചെയ്യുക ഒപ്കോഡ് ആണ്. ഫ്ലാഗുകൾ "op_flags" ന്റെ എട്ട് ബിറ്റുകൾ നൽകുന്നു, കൂടാതെ, മുകളിലേക്ക് മാറ്റി
എട്ട് ബിറ്റുകൾ, "op_private" എന്നതിന്റെ എട്ട് ബിറ്റുകൾ. const_meth സ്ഥിരമായ ഒരു രീതി നൽകുന്നു
പേര്; അത് പങ്കിട്ട COW സ്ട്രിംഗ് ആയിരിക്കണം. പിന്തുണയ്ക്കുന്ന ഒപ്‌ടൈപ്പുകൾ: OP_METHOD_NAMED.

OP * newMETHOP_named(I32 തരം, I32 ഫ്ലാഗുകൾ,
SV *const_meth)

പുതിയ NULLLIST
ഒരു ശൂന്യമായ പട്ടികയെ പ്രതിനിധീകരിക്കുന്ന ഒരു പുതിയ "സ്റ്റബ്" ഓപ് നിർമ്മിക്കുകയും പരിശോധിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു
എക്സ്പ്രഷൻ.

OP * newNULLLIST()

newOP ഏതെങ്കിലും അടിസ്ഥാന തരത്തിന്റെ (അധികം ഇല്ലാത്ത ഏത് തരത്തിലുമുള്ള ഒരു OP നിർമ്മിക്കുകയും പരിശോധിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു
ഫീൽഡുകൾ). ടൈപ്പ് ചെയ്യുക ഒപ്കോഡ് ആണ്. ഫ്ലാഗുകൾ "op_flags" എട്ട് ബിറ്റുകൾ നൽകുന്നു, കൂടാതെ,
"op_private" ന്റെ എട്ട് ബിറ്റുകൾ, എട്ട് ബിറ്റുകൾ മുകളിലേക്ക് മാറ്റി.

OP * newOP(I32 തരം, I32 ഫ്ലാഗുകൾ)

പുതിയPADOP
ഒരു റഫറൻസ് ഉൾപ്പെടുന്ന ഏത് തരത്തിലുമുള്ള ഒരു OP നിർമ്മിക്കുകയും പരിശോധിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു
പാഡ് ഘടകം. ടൈപ്പ് ചെയ്യുക ഒപ്കോഡ് ആണ്. ഫ്ലാഗുകൾ "op_flags" എട്ട് ബിറ്റുകൾ നൽകുന്നു. എ
പാഡ് സ്ലോട്ട് സ്വയമേവ അലോക്കേറ്റ് ചെയ്യപ്പെടുന്നു, കൂടാതെ ജനസംഖ്യയുള്ളതുമാണ് sv; ഈ പ്രവർത്തനം എടുക്കുന്നു
ഒരു റഫറൻസിന്റെ ഉടമസ്ഥാവകാശം.

ithreads ഉപയോഗിക്കുന്നതിനായി Perl കംപൈൽ ചെയ്തിട്ടുണ്ടെങ്കിൽ മാത്രമേ ഈ ഫംഗ്ഷൻ നിലനിൽക്കൂ.

OP * newPADOP(I32 തരം, I32 ഫ്ലാഗുകൾ, SV *sv)

newPMOP ഏതെങ്കിലും പാറ്റേൺ പൊരുത്തപ്പെടുന്ന തരത്തിന്റെ ഒരു ഓപ് നിർമ്മിക്കുകയും പരിശോധിക്കുകയും നൽകുകയും ചെയ്യുന്നു. ടൈപ്പ് ചെയ്യുക ആകുന്നു
ഒപ്കോഡ്. ഫ്ലാഗുകൾ "op_flags" ന്റെ എട്ട് ബിറ്റുകൾ നൽകുന്നു, കൂടാതെ എട്ട് ബിറ്റുകൾ മുകളിലേക്ക് മാറ്റി
"op_private" ന്റെ എട്ട് ബിറ്റുകൾ.

OP * newPMOP(I32 തരം, I32 ഫ്ലാഗുകൾ)

newPVOP ഒരു ഉൾച്ചേർത്തത് ഉൾപ്പെടുന്ന ഏതെങ്കിലും തരത്തിലുള്ള ഒരു OP നിർമ്മിക്കുകയും പരിശോധിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു
സി-ലെവൽ പോയിന്റർ (PV). ടൈപ്പ് ചെയ്യുക ഒപ്കോഡ് ആണ്. ഫ്ലാഗുകൾ എട്ട് ബിറ്റുകൾ നൽകുന്നു
"op_flags". pv C-ലെവൽ പോയിന്റർ വിതരണം ചെയ്യുന്നു, അത് ഉപയോഗിച്ച് അനുവദിച്ചിരിക്കണം
"PerlMemShared_malloc"; ഓപ് നശിപ്പിക്കപ്പെടുമ്പോൾ മെമ്മറി സ്വതന്ത്രമാകും.

OP * newPVOP(I32 തരം, I32 ഫ്ലാഗുകൾ, char *pv)

പുതിയ റേഞ്ച്
സബോർഡിനേറ്റ് "ഫ്ലിപ്പ്", "ഫ്ലോപ്പ്" ഓപ്‌സുകൾക്കൊപ്പം ഒരു "റേഞ്ച്" ഓപ്‌ നിർമ്മിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു.
ഫ്ലാഗുകൾ "ഫ്ലിപ്പ്" ഓപ്പിനായി "op_flags" ന്റെ എട്ട് ബിറ്റുകൾ നൽകുന്നു, കൂടാതെ എട്ട് മുകളിലേക്ക് മാറ്റി
ബിറ്റുകൾ, "ഫ്ലിപ്പ്", "റേഞ്ച്" ഓപ്‌സിനായി "op_private" ന്റെ എട്ട് ബിറ്റുകൾ ഒഴികെ
മൂല്യം 1 ഉള്ള ബിറ്റ് സ്വയമേവ സജ്ജീകരിച്ചിരിക്കുന്നു. ഇടത്തെ ഒപ്പം വലത് വിതരണം ചെയ്യുക
ശ്രേണിയുടെ അവസാന പോയിന്റുകളെ നിയന്ത്രിക്കുന്ന എക്സ്പ്രഷനുകൾ; അവർ ഇതുമൂലം ദഹിപ്പിക്കപ്പെടുന്നു
പ്രവർത്തിക്കുകയും നിർമ്മിച്ച ഓപ് ട്രീയുടെ ഭാഗമാവുകയും ചെയ്യുക.

OP * new RANGE(I32 ഫ്ലാഗുകൾ, OP *ഇടത്, OP *വലത്)

പുതിയSLICEOP
ഒരു "lslice" (ലിസ്റ്റ് സ്ലൈസ്) op നിർമ്മിക്കുകയും പരിശോധിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു. ഫ്ലാഗുകൾ നൽകുന്നു
എട്ട് ബിറ്റുകൾ "op_flags", കൂടാതെ "OPf_KIDS" സ്വയമേവ സജ്ജീകരിക്കപ്പെടും, കൂടാതെ,
എട്ട് ബിറ്റുകൾ മുകളിലേക്ക് മാറ്റി, "op_private" എന്നതിന്റെ എട്ട് ബിറ്റുകൾ, കൂടെയുള്ള ബിറ്റ് ഒഴികെ
മൂല്യം 1 അല്ലെങ്കിൽ 2 ആവശ്യാനുസരണം സ്വയമേവ സജ്ജീകരിച്ചിരിക്കുന്നു. ലിസ്റ്റ്വൽ ഒപ്പം സബ്സ്ക്രിപ്റ്റ് വിതരണം ചെയ്യുക
സ്ലൈസിന്റെ പാരാമീറ്ററുകൾ; അവ ഈ പ്രവർത്തനത്താൽ ദഹിപ്പിക്കപ്പെടുകയും അതിന്റെ ഭാഗമാവുകയും ചെയ്യുന്നു
ഓപ് ട്രീ നിർമ്മിച്ചു.

OP * newSLICEOP(I32 ഫ്ലാഗുകൾ, OP *സബ്‌സ്‌ക്രിപ്റ്റ്,
OP *ലിസ്റ്റ്വൽ)

പുതിയ STATEOP
ഒരു സംസ്ഥാന OP (COP) നിർമ്മിക്കുന്നു. സ്റ്റേറ്റ് ഒപി സാധാരണയായി ഒരു "നെക്സ്റ്റ് സ്റ്റേറ്റ്" ഓപ് ആണ്, പക്ഷേ ചെയ്യും
നിലവിൽ കംപൈൽ ചെയ്‌തിരിക്കുന്ന കോഡിനായി ഡീബഗ്ഗിംഗ് പ്രവർത്തനക്ഷമമാക്കിയിട്ടുണ്ടെങ്കിൽ ഒരു "dbstate" op ആകുക. സംസ്ഥാനം
"PL_curcop" (അല്ലെങ്കിൽ "PL_compiling") എന്നതിൽ നിന്നാണ് op ജനസംഖ്യയുള്ളത്. എങ്കിൽ ലേബൽ അസാധുവാണ്, അത്
സ്റ്റേറ്റ് ഒപിയിലേക്ക് അറ്റാച്ചുചെയ്യാൻ ഒരു ലേബലിന്റെ പേര് നൽകുന്നു; ഈ പ്രവർത്തനം എടുക്കുന്നു
ചൂണ്ടിക്കാണിച്ച മെമ്മറിയുടെ ഉടമസ്ഥത ലേബൽ, അത് സ്വതന്ത്രമാക്കുകയും ചെയ്യും. ഫ്ലാഗുകൾ നൽകുന്നു
സ്റ്റേറ്റ് ഒപിക്കായി എട്ട് ബിറ്റുകൾ "op_flags".

If o അസാധുവാണ്, സ്റ്റേറ്റ് ഒപി തിരികെ ലഭിച്ചു. അല്ലെങ്കിൽ സ്റ്റേറ്റ് ഒപി കൂടിച്ചേർന്നതാണ് o
ഒരു "lineseq" ലിസ്റ്റ് ഓപ്പിലേക്ക്, അത് തിരികെ നൽകുന്നു. o ഈ ഫംഗ്‌ഷൻ ഉപയോഗിച്ചാണ് ഉപയോഗിക്കുന്നത്
തിരിച്ചുവന്ന ഓപ് ട്രീയുടെ ഭാഗമാകുന്നു.

OP * newSTATEOP(I32 ഫ്ലാഗുകൾ, ചാർ *ലേബൽ, OP *o)

newSVOP ഒരു ഉൾച്ചേർത്ത SV ഉൾപ്പെടുന്ന ഏത് തരത്തിലുമുള്ള ഒരു OP നിർമ്മിക്കുകയും പരിശോധിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു.
ടൈപ്പ് ചെയ്യുക ഒപ്കോഡ് ആണ്. ഫ്ലാഗുകൾ "op_flags" എട്ട് ബിറ്റുകൾ നൽകുന്നു. sv ലേക്ക് SV നൽകുന്നു
ഒപിയിൽ ഉൾപ്പെടുത്തുക; ഈ ഫംഗ്‌ഷൻ അതിന്റെ ഒരു റഫറൻസിന്റെ ഉടമസ്ഥാവകാശം എടുക്കുന്നു.

OP * newSVOP(I32 തരം, I32 ഫ്ലാഗുകൾ, SV *sv)

newUNOP ഏതെങ്കിലും അനിയന്ത്രിതമായ ഒരു op നിർമ്മിക്കുകയും പരിശോധിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു. ടൈപ്പ് ചെയ്യുക ഒപ്കോഡ് ആണ്.
ഫ്ലാഗുകൾ എട്ട് ബിറ്റുകൾ "op_flags" നൽകുന്നു, അല്ലാതെ "OPf_KIDS" സജ്ജീകരിക്കും
ആവശ്യമെങ്കിൽ സ്വയമേവ, കൂടാതെ, എട്ട് ബിറ്റുകൾ മുകളിലേക്ക് മാറ്റി, എട്ട് ബിറ്റുകൾ
"op_private", മൂല്യം 1 ഉള്ള ബിറ്റ് സ്വയമേവ സജ്ജീകരിച്ചിരിക്കുന്നു എന്നതൊഴിച്ചാൽ. ആദ്യം
unary op-ന്റെ നേരിട്ടുള്ള കുട്ടിയാകാൻ ഒരു ഓപ്ഷണൽ ഓപ് നൽകുന്നു; അതു കഴിക്കുന്നു
ഈ പ്രവർത്തനം നിർമ്മിത ഓപ് ട്രീയുടെ ഭാഗമാകും.

OP * newUNOP(I32 തരം, I32 ഫ്ലാഗുകൾ, OP *ആദ്യം)

പുതിയUNOP_AUX
"newUNOP" എന്നതിന് സമാനമാണ്, എന്നാൽ പകരം op_aux ഉപയോഗിച്ച് ഒരു UNOP_AUX ഘടന സൃഷ്ടിക്കുന്നു
ഓക്സിലേക്ക് ആരംഭിച്ചു

OP* newUNOP_AUX(I32 തരം, I32 ഫ്ലാഗുകൾ, OP* ആദ്യം,
UNOP_AUX_item *aux)

പുതിയWHENOP
"എപ്പോൾ" ബ്ലോക്ക് പ്രകടിപ്പിക്കുന്ന ഒരു ഓപ് ട്രീ നിർമ്മിക്കുകയും പരിശോധിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു. അവസ്ഥ
ടെസ്റ്റ് എക്സ്പ്രഷൻ നൽകുന്നു, കൂടാതെ ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്ന ബ്ലോക്ക് നൽകുന്നു
പരിശോധന ശരിയാണെന്ന് വിലയിരുത്തുകയാണെങ്കിൽ; അവ ഈ പ്രവർത്തനത്താൽ ദഹിപ്പിക്കപ്പെടുകയും ഭാഗമാവുകയും ചെയ്യുന്നു
നിർമ്മിച്ച ഓപ് ട്രീയുടെ. അവസ്ഥ DWIM ആയി വ്യാഖ്യാനിക്കപ്പെടും, പലപ്പോഴും a
$_ എന്നതുമായുള്ള താരതമ്യം, ഒരു "ഡിഫോൾട്ട്" ബ്ലോക്ക് സൃഷ്ടിക്കുന്നതിന് അസാധുവായിരിക്കാം.

OP * newWHENOP(OP *cond, OP *ബ്ലോക്ക്)

newWHILEOP
"വെയിൽ" ലൂപ്പ് പ്രകടിപ്പിക്കുന്ന ഒരു ഓപ് ട്രീ നിർമ്മിക്കുകയും പരിശോധിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു. ഇതൊരു
ഹെവിവെയ്റ്റ് ലൂപ്പ്, "അവസാനം" കൂടാതെ ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കാൻ അനുവദിക്കുന്ന ഘടന
അത് പോലെ ഉള്ള.

ലൂപ്പ് ലൂപ്പിൽ ഉപയോഗിക്കാനുള്ള ഒരു ഓപ്ഷണൽ പ്രീ-കൺസ്‌ട്രക്‌ട്ഡ് "എന്റർലൂപ്പ്" ഓപ് ആണ്; അങ്ങനെ എങ്കിൽ
null അപ്പോൾ അനുയോജ്യമായ ഒരു op സ്വയമേവ നിർമ്മിക്കപ്പെടും. exr വിതരണം ചെയ്യുന്നു
ലൂപ്പിന്റെ നിയന്ത്രണ എക്സ്പ്രഷൻ. ബ്ലോക്ക് ലൂപ്പിന്റെ പ്രധാന ഭാഗം വിതരണം ചെയ്യുന്നു, കൂടാതെ കണ്ടം
ഓപ്ഷണലായി ശരീരത്തിന്റെ രണ്ടാം പകുതിയായി പ്രവർത്തിക്കുന്ന ഒരു "തുടരുക" ബ്ലോക്ക് നൽകുന്നു.
ഈ ഒപ്‌ട്രീ ഇൻപുട്ടുകളെല്ലാം ഈ ഫംഗ്‌ഷൻ ഉപയോഗിക്കുകയും അതിന്റെ ഭാഗമാവുകയും ചെയ്യുന്നു
ഓപ് ട്രീ നിർമ്മിച്ചു.

ഫ്ലാഗുകൾ "leaveloop" op-ന് വേണ്ടി "op_flags" ന്റെ എട്ട് ബിറ്റുകൾ നൽകുന്നു, ഒപ്പം ഷിഫ്റ്റ് അപ്പ്
എട്ട് ബിറ്റുകൾ, "leaveloop" op-നുള്ള "op_private" ന്റെ എട്ട് ബിറ്റുകൾ, അതല്ലാതെ (ഇൻ
രണ്ട് സന്ദർഭങ്ങളിലും) ചില ബിറ്റുകൾ സ്വയമേവ സജ്ജീകരിക്കും. ഡീബഗ്ഗ് ചെയ്യാവുന്ന നിലവിൽ ഉപയോഗിക്കാത്തതാണ്
എപ്പോഴും 1 ആയിരിക്കണം. ഉണ്ട്_എന്റെ ലൂപ്പ് ബോഡി നിർബന്ധിതമാക്കാൻ ട്രൂ ആയി നൽകാം
സ്വന്തം പരിധിയിൽ ഉൾപ്പെടുത്തും.

OP * newWHILEOP(I32 ഫ്ലാഗുകൾ, I32 ഡീബഗ്ഗബിൾ,
ലൂപ്പ് *ലൂപ്പ്, OP *expr, OP *ബ്ലോക്ക്,
OP *cont, I32 has_my)

ഒപ്ട്രീ കൃത്രിമം പ്രവർത്തനങ്ങൾ

അലോക്കോപ്സ്റ്റാഷ്
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ത്രെഡഡ് ബിൽഡിന് കീഴിൽ മാത്രം ലഭ്യം, ഈ ഫംഗ്ഷൻ ഒരു എൻട്രി അനുവദിക്കുന്നു
"PL_stashpad" അതിലേക്ക് പാസ്സാക്കിയ സ്റ്റാഷിനുള്ളതാണ്.

PADOFFSET alloccopstash(HV *hv)

ബ്ലോക്ക്_എൻഡ്
കംപൈൽ-ടൈം സ്കോപ്പ് എക്സിറ്റ് കൈകാര്യം ചെയ്യുന്നു. തറ സേവ്സ്റ്റാക്ക് സൂചിക തിരിച്ചുനൽകുന്നു
"ബ്ലോക്ക്_സ്റ്റാർട്ട്", കൂടാതെ സെക് ബ്ലോക്കിന്റെ ശരീരമാണ്. ബ്ലോക്ക് തിരികെ നൽകുന്നു, ഒരുപക്ഷേ
തിരുത്തപ്പെട്ടത്.

OP * block_end(I32 ഫ്ലോർ, OP *seq)

ബ്ലോക്ക്_ആരംഭം
കംപൈൽ-ടൈം സ്കോപ്പ് എൻട്രി കൈകാര്യം ചെയ്യുന്നു. ബ്ലോക്ക് എക്സിറ്റിൽ പുനഃസ്ഥാപിക്കുന്നതിന് സൂചനകൾ ക്രമീകരിക്കുന്നു
കൂടാതെ ലെക്സിക്കൽ വേരിയബിളുകളുടെ വ്യാപ്തി ശരിയാക്കാൻ പാഡ് സീക്വൻസ് നമ്പറുകളും കൈകാര്യം ചെയ്യുന്നു.
"block_end" ഉപയോഗിച്ചുള്ള ഒരു സേവ്സ്റ്റാക്ക് സൂചിക നൽകുന്നു.

int block_start(int full)

ck_entersub_args_list
ഒരു "എന്റർസബ്" ഓപ് ട്രീയുടെ ആർഗ്യുമെന്റ് ഭാഗത്തിന്റെ ഡിഫോൾട്ട് ഫിക്സപ്പ് നടത്തുന്നു. ഈ
ഓരോ ആർഗ്യുമെന്റ് ഓപ്‌സിനും ലിസ്റ്റ് സന്ദർഭം പ്രയോഗിക്കുന്നത് ഉൾക്കൊള്ളുന്നു. ഇതാണ്
"&" എന്ന് അടയാളപ്പെടുത്തിയിരിക്കുന്ന കോളിൽ അല്ലെങ്കിൽ ഒരു മെത്തേഡ് കോൾ അല്ലെങ്കിൽ ഒരു കോളിൽ ഉപയോഗിക്കുന്ന സാധാരണ ചികിത്സ
ഒരു സബ്റൂട്ടീൻ റഫറൻസ് വഴിയോ അല്ലെങ്കിൽ വിളിക്കുന്നയാൾക്ക് സാധ്യമല്ലാത്ത മറ്റേതെങ്കിലും കോളിലൂടെയോ
കംപൈൽ സമയത്ത് തിരിച്ചറിഞ്ഞു, അല്ലെങ്കിൽ വിളിക്കുന്നയാൾക്ക് പ്രോട്ടോടൈപ്പ് ഇല്ലാത്ത ഒരു കോൾ.

OP * ck_entersub_args_list(OP *entersubop)

ck_entersub_args_proto
a അടിസ്ഥാനമാക്കി ഒരു "entersub" op ട്രീയുടെ ആർഗ്യുമെന്റുകളുടെ ഭാഗത്തിന്റെ ഫിക്സപ്പ് നടത്തുന്നു
സബ്റൂട്ടീൻ പ്രോട്ടോടൈപ്പ്. ഇത് ആർഗ്യുമെന്റ് ops-ൽ വിവിധ മാറ്റങ്ങൾ വരുത്തുന്നു
"refgen" ഓപ്‌സ് ചേർക്കുന്നത് വരെ സന്ദർഭം പ്രയോഗിക്കുകയും നമ്പർ പരിശോധിക്കുകയും ചെയ്യുക
പ്രോട്ടോടൈപ്പ് നിർദ്ദേശിച്ചതുപോലെ, വാക്യഘടനയുടെ തരം ആർഗ്യുമെന്റുകൾ. ഇതാണ് മാനദണ്ഡം
ഒരു സബ്റൂട്ടീൻ കോളിൽ ഉപയോഗിക്കുന്ന ചികിത്സ, "&" എന്ന് അടയാളപ്പെടുത്തിയിട്ടില്ല, വിളിക്കുന്നയാൾ എവിടെയായിരിക്കാം
കംപൈൽ സമയത്ത് തിരിച്ചറിഞ്ഞ് ഒരു പ്രോട്ടോടൈപ്പ് ഉണ്ട്.

പ്രോട്ടോസ്വി കോളിൽ പ്രയോഗിക്കേണ്ട സബ്റൂട്ടീൻ പ്രോട്ടോടൈപ്പ് നൽകുന്നു. അത് ഒരു ആകാം
സാധാരണ നിർവചിക്കപ്പെട്ട സ്കെയിലർ, അതിൽ സ്ട്രിംഗ് മൂല്യം ഉപയോഗിക്കും. പകരമായി, വേണ്ടി
സൗകര്യാർത്ഥം, ഇത് ഒരു സബ്റൂട്ടീൻ ഒബ്‌ജക്റ്റ് ആയിരിക്കാം ("CV*" അത് "SV*" ലേക്ക് കാസ്‌റ്റ് ചെയ്‌തിരിക്കുന്നു)
ഒരു പ്രോട്ടോടൈപ്പ് ഉള്ളത്. വിതരണം ചെയ്ത പ്രോട്ടോടൈപ്പ്, ഏത് രൂപത്തിൽ വേണമെങ്കിലും ആവശ്യമില്ല
ഓപ് ട്രീ പരാമർശിച്ച യഥാർത്ഥ കോളിയെ പൊരുത്തപ്പെടുത്താൻ.

ആർഗ്യുമെന്റ് ഓപ്‌സ് പ്രോട്ടോടൈപ്പിനോട് വിയോജിക്കുന്നുവെങ്കിൽ, ഉദാഹരണത്തിന് ഒരു
അസ്വീകാര്യമായ നിരവധി വാദങ്ങൾ, സാധുവായ ഒരു ഓപ് ട്രീ എന്തായാലും തിരികെ നൽകും. പിശക്
പാഴ്‌സർ അവസ്ഥയിൽ പ്രതിഫലിക്കുന്നു, സാധാരണയായി ഒരു അപവാദത്തിന് കാരണമാകുന്നു
സംഭവിച്ച എല്ലാ കംപൈലേഷൻ പിശകുകളും ഉൾക്കൊള്ളുന്ന ഉയർന്ന തലത്തിലുള്ള പാഴ്‌സിംഗ്. ഇൻ
പിശക് സന്ദേശം, വിളിക്കുന്നയാളെ നിർവചിച്ചിരിക്കുന്ന പേരിലാണ് പരാമർശിക്കുന്നത് namegv
പാരാമീറ്റർ.

OP * ck_entersub_args_proto(OP *entersubop,
GV *namegv, SV *protosv)

ck_entersub_args_proto_or_list
ഒന്നുകിൽ അടിസ്ഥാനമാക്കി "എന്റർസബ്" ഓപ് ട്രീയുടെ ആർഗ്യുമെന്റുകളുടെ ഭാഗത്തിന്റെ ഫിക്സപ്പ് നടത്തുന്നു
ഒരു സബ്റൂട്ടീൻ പ്രോട്ടോടൈപ്പ് അല്ലെങ്കിൽ ഡിഫോൾട്ട് ലിസ്റ്റ്-സന്ദർഭ പ്രോസസ്സിംഗ് ഉപയോഗിക്കുന്നു. ഇതാണ്
ഒരു സബ്റൂട്ടീൻ കോളിൽ ഉപയോഗിക്കുന്ന സാധാരണ ചികിത്സ, "&" എന്ന് അടയാളപ്പെടുത്തിയിട്ടില്ല
കംപൈൽ സമയത്ത് കോളിയെ തിരിച്ചറിയാൻ കഴിയും.

പ്രോട്ടോസ്വി കോളിൽ പ്രയോഗിക്കേണ്ട സബ്റൂട്ടീൻ പ്രോട്ടോടൈപ്പ് നൽകുന്നു, അല്ലെങ്കിൽ സൂചിപ്പിക്കുന്നു
പ്രോട്ടോടൈപ്പ് ഇല്ല എന്ന്. ഇത് ഒരു സാധാരണ സ്കെയിലർ ആയിരിക്കാം, അങ്ങനെയാണെങ്കിൽ
നിർവചിച്ചാൽ, സ്ട്രിംഗ് മൂല്യം ഒരു പ്രോട്ടോടൈപ്പായി ഉപയോഗിക്കും, അത് നിർവചിച്ചിട്ടില്ലെങ്കിൽ
അപ്പോൾ പ്രോട്ടോടൈപ്പ് ഇല്ല. മറ്റൊരുതരത്തിൽ, സൗകര്യാർത്ഥം, അത് എ
സബ്റൂട്ടീൻ ഒബ്‌ജക്റ്റ് ("സിവി*" അത് "എസ്‌വി*" ലേക്ക് കാസ്‌റ്റ് ചെയ്‌തിരിക്കുന്നു), ഇതിന്റെ പ്രോട്ടോടൈപ്പ്
ഉണ്ടെങ്കിൽ അത് ഉപയോഗിക്കും. പ്രോട്ടോടൈപ്പ് (അല്ലെങ്കിൽ അതിന്റെ അഭാവം) വിതരണം ചെയ്തു
ഏത് രൂപമായാലും, op റഫറൻസ് ചെയ്ത യഥാർത്ഥ കോളുമായി പൊരുത്തപ്പെടേണ്ടതില്ല
വൃക്ഷം.

ആർഗ്യുമെന്റ് ഓപ്‌സ് പ്രോട്ടോടൈപ്പിനോട് വിയോജിക്കുന്നുവെങ്കിൽ, ഉദാഹരണത്തിന് ഒരു
അസ്വീകാര്യമായ നിരവധി വാദങ്ങൾ, സാധുവായ ഒരു ഓപ് ട്രീ എന്തായാലും തിരികെ നൽകും. പിശക്
പാഴ്‌സർ അവസ്ഥയിൽ പ്രതിഫലിക്കുന്നു, സാധാരണയായി ഒരു അപവാദത്തിന് കാരണമാകുന്നു
സംഭവിച്ച എല്ലാ കംപൈലേഷൻ പിശകുകളും ഉൾക്കൊള്ളുന്ന ഉയർന്ന തലത്തിലുള്ള പാഴ്‌സിംഗ്. ഇൻ
പിശക് സന്ദേശം, വിളിക്കുന്നയാളെ നിർവചിച്ചിരിക്കുന്ന പേരിലാണ് പരാമർശിക്കുന്നത് namegv
പാരാമീറ്റർ.

OP * ck_entersub_args_proto_or_list(OP *entersubop,
GV *namegv,
SV *protosv)

cv_const_sv
"cv" എന്നത് ഇൻലൈനിംഗിന് യോഗ്യമായ ഒരു സ്ഥിരമായ ഉപമാണെങ്കിൽ, സ്ഥിരമായ മൂല്യം നൽകുന്നു
സബ് വഴി തിരിച്ചു. അല്ലെങ്കിൽ, NULL നൽകുന്നു.

"newCONSTSUB" ഉപയോഗിച്ചോ അല്ലെങ്കിൽ "കോൺസ്റ്റന്റിൽ" വിവരിച്ചതുപോലെയോ സ്ഥിരമായ സബ്സ് സൃഷ്ടിക്കാൻ കഴിയും
ഫങ്ഷനുകൾ" perlsub ൽ.

SV* cv_const_sv(const CV *const cv)

cv_get_call_checker
ഒരു കോൾ പരിഹരിക്കാൻ ഉപയോഗിക്കുന്ന ഫംഗ്‌ഷൻ വീണ്ടെടുക്കുന്നു cv. പ്രത്യേകിച്ചും,
ഒരു സബ്റൂട്ടീൻ കോളിനായി "എന്റർസബ്" ഓപ് ട്രീയിൽ ഫംഗ്ഷൻ പ്രയോഗിക്കുന്നു, അടയാളപ്പെടുത്തിയിട്ടില്ല
"&" ഉപയോഗിച്ച്, കംപൈൽ സമയത്ത് വിളിക്കുന്നയാളെ തിരിച്ചറിയാൻ കഴിയും cv.

സി-ലെവൽ ഫംഗ്‌ഷൻ പോയിന്റർ തിരികെ നൽകി *ckfun_p, അതിനുള്ള ഒരു എസ്.വി
തിരികെ പ്രവേശിച്ചു *ckobj_p. പ്രവർത്തനത്തെ ഈ രീതിയിൽ വിളിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്:

entersubop = (*ckfun_p)(aTHX_ entersubop, namegv, (*ckobj_p));

ഈ കോളിൽ, entersubop "entersub" op-ലേക്കുള്ള ഒരു പോയിന്ററാണ്, അത് മാറ്റിസ്ഥാപിക്കാം
ചെക്ക് ഫംഗ്ഷൻ വഴി, ഒപ്പം namegv ഉപയോഗിക്കേണ്ട പേര് നൽകുന്ന ഒരു ജിവി ആണ്
ആവശ്യമെങ്കിൽ "entersub" op-ന്റെ കോളിയെ റഫർ ചെയ്യാൻ ചെക്ക് ഫംഗ്‌ഷൻ വഴി
ഏതെങ്കിലും ഡയഗ്നോസ്റ്റിക്സ് പുറപ്പെടുവിക്കുക. നിലവാരമില്ലാത്ത രീതിയിൽ ചെക്ക് ഫംഗ്ഷൻ പ്രയോഗിക്കാൻ ഇത് അനുവദിച്ചിരിക്കുന്നു
മറ്റൊരു സബ്റൂട്ടീനിലേക്കോ ഒരു മെത്തേഡ് കോളിലേക്കോ ഉള്ള ഒരു കോൾ പോലുള്ള സാഹചര്യങ്ങൾ.

സ്ഥിരസ്ഥിതിയായി, ഫംഗ്ഷൻ Perl_ck_entersub_args_proto_or_list ആണ്, കൂടാതെ SV
പരാമീറ്റർ ആണ് cv തന്നെ. ഇത് സ്റ്റാൻഡേർഡ് പ്രോട്ടോടൈപ്പ് പ്രോസസ്സിംഗ് നടപ്പിലാക്കുന്നു. അത് ആവാം
"cv_set_call_checker" വഴി ഒരു പ്രത്യേക സബ്റൂട്ടീനിനായി മാറ്റി.

അസാധുവായ cv_get_call_checker(CV *cv,
Perl_call_checker *ckfun_p,
SV **ckobj_p)

cv_set_call_checker
"cv_set_call_checker_flags" എന്നതിന്റെ യഥാർത്ഥ രൂപം, അത് കടന്നുപോകുന്നു
"CALL_CHECKER_REQUIRE_GV" ബാക്ക്‌വേർഡ്-കമ്പാറ്റിബിളിറ്റിക്കായി ഫ്ലാഗ്.

അസാധുവായ cv_set_call_checker(CV *cv,
Perl_call_checker ckfun,
SV *ckobj)

cv_set_call_checker_flags
ഒരു കോൾ പരിഹരിക്കാൻ ഉപയോഗിക്കുന്ന ഫംഗ്‌ഷൻ സജ്ജീകരിക്കുന്നു cv. പ്രത്യേകിച്ചും, ദി
ഒരു സബ്റൂട്ടീൻ കോളിനായി "എന്റർസബ്" ഓപ് ട്രീയിൽ ഫംഗ്ഷൻ പ്രയോഗിക്കുന്നു, അടയാളപ്പെടുത്തിയിട്ടില്ല
"&" ഉപയോഗിച്ച്, കംപൈൽ സമയത്ത് വിളിക്കുന്നയാളെ തിരിച്ചറിയാൻ കഴിയും cv.

സി-ലെവൽ ഫംഗ്‌ഷൻ പോയിന്റർ വിതരണം ചെയ്‌തിരിക്കുന്നു ckfun, അതിനുള്ള ഒരു എസ്.വി
ൽ വിതരണം ചെയ്തു ckobj. പ്രവർത്തനം ഇതുപോലെ നിർവചിക്കണം:

STATIC OP * ckfun(pTHX_ OP *op, GV *namegv, SV *ckobj)

ഈ രീതിയിൽ വിളിക്കാൻ ഉദ്ദേശിക്കുന്നു:

entersubop = ckfun(aTHX_ entersubop, namegv, ckobj);

ഈ കോളിൽ, entersubop "entersub" op-ലേക്കുള്ള ഒരു പോയിന്ററാണ്, അത് മാറ്റിസ്ഥാപിക്കാം
ചെക്ക് ഫംഗ്ഷൻ വഴി, ഒപ്പം namegv ഉപയോഗിക്കേണ്ട പേര് നൽകുന്നു
"എന്റർസബ്" ഓപ്പിന് എന്തെങ്കിലും എമിറ്റ് ചെയ്യേണ്ടതുണ്ടെങ്കിൽ അത് വിളിക്കുന്നയാളെ റഫർ ചെയ്യാൻ ഫംഗ്ഷൻ പരിശോധിക്കുക
ഡയഗ്നോസ്റ്റിക്സ്. നിലവാരമില്ലാത്ത രീതിയിൽ ചെക്ക് ഫംഗ്ഷൻ പ്രയോഗിക്കാൻ ഇത് അനുവദിച്ചിരിക്കുന്നു
മറ്റൊരു സബ്റൂട്ടീനിലേക്കോ ഒരു മെത്തേഡ് കോളിലേക്കോ ഉള്ള ഒരു കോൾ പോലുള്ള സാഹചര്യങ്ങൾ.

namegv യഥാർത്ഥത്തിൽ ഒരു ജിവി ആയിരിക്കില്ല. കാര്യക്ഷമതയ്ക്കായി, perl ഒരു CV അല്ലെങ്കിൽ മറ്റ് SV പാസ്സാക്കിയേക്കാം
പകരം. പാസ്സായതെന്തും "cv_name" എന്നതിലേക്കുള്ള ആദ്യ ആർഗ്യുമെന്റായി ഉപയോഗിക്കാം. നിങ്ങൾ
"CALL_CHECKER_REQUIRE_GV" എന്നതിൽ ഉൾപ്പെടുത്തി ഒരു GV പാസാക്കാൻ perl-നെ നിർബന്ധിക്കാം ഫ്ലാഗുകൾ.

ഒരു പ്രത്യേക സിവിയുടെ നിലവിലെ ക്രമീകരണം "cv_get_call_checker" വഴി വീണ്ടെടുക്കാനാകും.

അസാധുവായ cv_set_call_checker_flags(
CV *cv, Perl_call_checker ckfun, SV *ckobj,
U32 പതാകകൾ
)

ലിങ്ക് ലിസ്റ്റ്
ഒപ്‌ട്രീയുടെ റൂട്ട് നൽകിയാൽ, "op_next" ഉപയോഗിച്ച് ട്രീയെ എക്‌സിക്യൂഷൻ ക്രമത്തിൽ ലിങ്ക് ചെയ്യുക
പോയിന്ററുകൾ, എക്സിക്യൂട്ട് ചെയ്ത ആദ്യ ഓപ് തിരികെ നൽകുക. ഇത് ഇതിനകം ചെയ്തിട്ടുണ്ടെങ്കിൽ, അത് ചെയ്യും
വീണ്ടും ചെയ്യരുത്, "o->op_next" തിരികെ നൽകും. "o->op_next" ഇതിനകം ഇല്ലെങ്കിൽ
സജ്ജമാക്കുക, o കുറഞ്ഞത് ഒരു "UNOP" ആയിരിക്കണം.

OP* ലിങ്ക്ലിസ്റ്റ്(OP *o)

പുതിയCONSTSUB
"newCONSTSUB_flags" കാണുക.

CV* newCONSTSUB(HV* സ്റ്റാഷ്, കോൺസ്റ്റ് ചാർ* പേര്, SV* sv)

പുതിയCONSTSUB_ഫ്ലാഗുകൾ
യോഗ്യമായ Perl "sub FOO () { 123 }" ന് തുല്യമായ ഒരു സ്ഥിരമായ സബ് സൃഷ്ടിക്കുന്നു
കംപൈൽ സമയത്ത് ഇൻലൈനിംഗിനായി.

നിലവിൽ, "ഫ്ലാഗുകളുടെ" ഉപയോഗപ്രദമായ മൂല്യം SVf_UTF8 ആണ്.

പുതുതായി സൃഷ്‌ടിച്ച സബ്‌റൂട്ടീൻ എസ്‌വിയിൽ പാസാക്കിയ റഫറൻസിന്റെ ഉടമസ്ഥാവകാശം ഏറ്റെടുക്കുന്നു.

SV-യ്‌ക്കായി NULL കടന്നുപോകുന്നത് "സബ് ബാർ () {}" എന്നതിന് തുല്യമായ ഒരു സ്ഥിരമായ ഉപവിഭാഗം സൃഷ്ടിക്കുന്നു, അത്
ഒരു ഡിസ്ട്രക്റ്ററായി ഉപയോഗിക്കുകയാണെങ്കിൽ വിളിക്കില്ല, എന്നാൽ ഒരു കോളിന്റെ ഓവർഹെഡ് അടിച്ചമർത്തും
"ഓട്ടോലോഡ്" എന്നതിലേക്ക്. (എന്നിരുന്നാലും, ഈ ഫോം കംപൈൽ സമയത്ത് ഇൻലൈനിംഗിന് യോഗ്യമല്ല.)

CV* newCONSTSUB_flags(HV* സ്റ്റാഷ്, കോൺസ്റ്റ് ചാർ* പേര്,
STRLEN ലെൻ, U32 ഫ്ലാഗുകൾ, SV* sv)

newXS, XSUB-കളെ Perl subs ആയി ഹുക്ക് അപ്പ് ചെയ്യാൻ "xsubpp" ഉപയോഗിക്കുന്നു. ഫയലിന്റെ പേര് സ്റ്റാറ്റിക് ആയിരിക്കണം
സംഭരണം, ഇത് നേരിട്ട് ഉപയോഗിക്കുന്നതിനാൽ CvFILE(), ഒരു കോപ്പി ഉണ്ടാക്കാതെ.

OPHAS_SIBLING
ഒയ്ക്ക് ഒരു സഹോദരനുണ്ടെങ്കിൽ ശരിയാണെന്ന് തിരികെ നൽകുന്നു

bool OpHAS_SIBLING(OP *o)

OpLASTSIB_set
കൂടുതൽ സഹോദരങ്ങൾ ഇല്ലെന്ന് മാർക്ക് ഒ. "PERL_OP_PARENT" ബിൽഡുകളിൽ, o ആയി അടയാളപ്പെടുത്തുന്നു
നിർദ്ദിഷ്ട രക്ഷകർത്താവ് ഉള്ളത്. "OpMORESIB_set", "OpMAYBESIB_set" എന്നിവയും കാണുക. എ
ഉയർന്ന തലത്തിലുള്ള ഇന്റർഫേസ്, "op_sibling_splice" കാണുക.

ശൂന്യമായ OpLASTSIB_set(OP *o, OP *പാരന്റ്)

OpMAYBESIB_set
സിബ് ആണോ എന്നതിനെ ആശ്രയിച്ച് സോപാധികമായി "OpMORESIB_set" അല്ലെങ്കിൽ "OpLASTSIB_set" ചെയ്യുന്നു
അസാധുവായ. ഉയർന്ന തലത്തിലുള്ള ഇന്റർഫേസിനായി, "op_sibling_splice" കാണുക.

ശൂന്യമായ OpMAYBESIB_set(OP *o, OP *sib, OP *പാരന്റ്)

OpMORESIB_set
o യുടെ സഹോദരനെ പൂജ്യമല്ലാത്ത മൂല്യമായ സിബിലേക്ക് സജ്ജമാക്കുന്നു. "OpLASTSIB_set" എന്നിവയും കാണുക
"OpMAYBESIB_set". ഉയർന്ന തലത്തിലുള്ള ഇന്റർഫേസിനായി, "op_sibling_splice" കാണുക.

ശൂന്യമായ OpMORESIB_set(OP *o, OP *sib)

ഒപ്സിബ്ലിംഗ്
ഒയുടെ സഹോദരനെ നൽകുന്നു, അല്ലെങ്കിൽ സഹോദരൻ ഇല്ലെങ്കിൽ NULL

OP* OpSIBLING(OP *o)

op_append_elem
ഒരു ലിസ്റ്റ്-ടൈപ്പ് ഓപ്പിനുള്ളിൽ നേരിട്ട് അടങ്ങിയിരിക്കുന്ന ഓപ്‌സിന്റെ ലിസ്റ്റിലേക്ക് ഒരു ഇനം കൂട്ടിച്ചേർക്കുക,
നീട്ടിയ പട്ടിക തിരികെ നൽകുന്നു. ആദ്യം ലിസ്റ്റ്-ടൈപ്പ് ഓപ് ആണ്, കൂടാതെ അവസാനത്തെ ആണ് op to
പട്ടികയിൽ ചേർക്കുക. ഒപ്ടൈപ്പ് ലിസ്റ്റിനായി ഉദ്ദേശിക്കുന്ന ഒപ്‌കോഡ് വ്യക്തമാക്കുന്നു. എങ്കിൽ ആദ്യം
ഇതിനകം ശരിയായ തരത്തിലുള്ള ഒരു ലിസ്റ്റ് അല്ല, അത് ഒന്നായി അപ്ഗ്രേഡ് ചെയ്യും. ഒന്നുകിൽ എങ്കിൽ
ആദ്യം or അവസാനത്തെ അസാധുവാണ്, മറ്റൊന്ന് മാറ്റമില്ലാതെ തിരികെ നൽകും.

OP * op_append_elem(I32 ഒപ്‌ടൈപ്പ്, OP *ആദ്യം, OP *അവസാനം)

op_append_list
രണ്ട് ലിസ്റ്റ്-ടൈപ്പ് ഓപ്‌സുകളിൽ നേരിട്ട് അടങ്ങിയിരിക്കുന്ന ഓപ്‌സിന്റെ ലിസ്റ്റുകൾ സംയോജിപ്പിക്കുക,
സംയുക്ത ലിസ്റ്റ് തിരികെ നൽകുന്നു. ആദ്യം ഒപ്പം അവസാനത്തെ സംയോജിപ്പിക്കാനുള്ള ലിസ്റ്റ്-ടൈപ്പ് ഓപ്‌സുകളാണ്.
ഒപ്ടൈപ്പ് ലിസ്റ്റിനായി ഉദ്ദേശിക്കുന്ന ഒപ്‌കോഡ് വ്യക്തമാക്കുന്നു. ഒന്നുകിൽ എങ്കിൽ ആദ്യം or അവസാനത്തെ അല്ല
ശരിയായ തരത്തിലുള്ള ഒരു ലിസ്റ്റ് ഇതിനകം തന്നെയുണ്ട്, അത് ഒന്നായി അപ്ഗ്രേഡ് ചെയ്യും. ഒന്നുകിൽ എങ്കിൽ ആദ്യം
or അവസാനത്തെ അസാധുവാണ്, മറ്റൊന്ന് മാറ്റമില്ലാതെ തിരികെ നൽകും.

OP * op_append_list(I32 ഒപ്‌ടൈപ്പ്, OP *ആദ്യം, OP *അവസാനം)

OP_CLASS
നൽകിയിരിക്കുന്ന OP-യുടെ ക്ലാസ് തിരികെ നൽകുക: അതായത്, അത് ഉപയോഗിക്കുന്ന *OP ഘടനകളിൽ ഏതാണ്.
കോർ ഓപ്‌സിനായി ഇത് നിലവിൽ PL_opargs-ൽ നിന്ന് വിവരങ്ങൾ ലഭിക്കുന്നു, അത് ലഭിക്കുന്നില്ല
ഉപയോഗിച്ച തരം എപ്പോഴും കൃത്യമായി പ്രതിഫലിപ്പിക്കുക. ഇഷ്‌ടാനുസൃത ഓപ്‌സിനായി തരം തിരിച്ച് നൽകുന്നു
രജിസ്ട്രേഷൻ, അത് കൃത്യമാണെന്ന് ഉറപ്പാക്കേണ്ടത് രജിസ്ട്രിയാണ്. ദി
തിരികെ നൽകിയ മൂല്യം op.h-ൽ നിന്നുള്ള OA_* സ്ഥിരാങ്കങ്ങളിൽ ഒന്നായിരിക്കും.

U32 OP_CLASS(OP *o)

op_contextualize
ഒരു പദപ്രയോഗത്തെ പ്രതിനിധീകരിക്കുന്ന ഒരു ഓപ് ട്രീയിലേക്ക് ഒരു വാക്യഘടനാ സന്ദർഭം പ്രയോഗിക്കുന്നു. o op ആണ്
മരം, ഒപ്പം സന്ദർഭം വ്യക്തമാക്കുന്നതിന് "G_SCALAR", "G_ARRAY" അല്ലെങ്കിൽ "G_VOID" ആയിരിക്കണം
പ്രയോഗിക്കാനുള്ള സന്ദർഭം. പരിഷ്കരിച്ച ഓപ് ട്രീ തിരികെ നൽകി.

OP * op_contextualize (OP *o, I32 സന്ദർഭം)

op_convert_list
പരിവർത്തനം ചെയ്യുന്നു o ഇത് ഇതിനകം ഒന്നല്ലെങ്കിൽ ഒരു ലിസ്റ്റ് ഓപ്പിലേക്ക്, തുടർന്ന് അതിനെ ഇതിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു
വ്യക്തമാക്കിയ ടൈപ്പ് ചെയ്യുക, അതിന്റെ ചെക്ക് ഫംഗ്‌ഷൻ വിളിക്കുന്നു, ഒരു ടാർഗെറ്റ് വേണമെങ്കിൽ അനുവദിക്കുന്നു,
ഒപ്പം മടക്കിക്കളയുന്ന സ്ഥിരാങ്കങ്ങളും.

"newLISTOP" വഴിയാണ് ഒരു ലിസ്റ്റ്-ടൈപ്പ് OP സാധാരണയായി ഒരു സമയം ഒരു കുട്ടി നിർമ്മിക്കുന്നത്,
"op_prepend_elem", "op_append_elem" എന്നിവ. പിന്നീട് ഒടുവിൽ അത് കൈമാറുന്നു
ശരിയായ തരത്തിലാക്കാൻ "op_convert_list".

OP * op_convert_list(I32 തരം, I32 ഫ്ലാഗുകൾ, OP *o)

OP_DESC നൽകിയ OP-യുടെ ഒരു ചെറിയ വിവരണം തിരികെ നൽകുക.

കോൺസ്റ്റ് ചാർ * OP_DESC(OP *o)

op_free സൗജന്യമായി ഒരു op. ഏതെങ്കിലും optree-ൽ നിന്ന് ഒരു op ഇനി ലിങ്ക് ചെയ്തിട്ടില്ലെങ്കിൽ മാത്രം ഇത് ഉപയോഗിക്കുക.

ശൂന്യമായ op_free(OP *o)

op_linklist
ഈ ഫംഗ്‌ഷൻ "LINKLIST" മാക്രോയുടെ നടപ്പിലാക്കലാണ്. അത് പാടില്ല
നേരിട്ട് വിളിച്ചു.

OP* op_linklist(OP *o)

op_lvalue
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു OP-നും അതിന്റെ കുട്ടികൾക്കും lvalue ("മാറ്റം വരുത്താവുന്ന") സന്ദർഭം പ്രചരിപ്പിക്കുക. ടൈപ്പ് ചെയ്യുക
കോൺടെക്‌സ്റ്റ് തരത്തെ പ്രതിനിധീകരിക്കുന്നു, അത് ചെയ്യുന്ന ഓപ്പിന്റെ തരത്തെ അടിസ്ഥാനമാക്കിയാണ്
പരിഷ്കരിക്കുന്നു, എന്നിരുന്നാലും "ലോക്കൽ()" എന്നത് OP_NULL പ്രതിനിധീകരിക്കുന്നു, കാരണം അതിന് op തരമില്ല
അതിന്റേതായ (ഇത് lvalue op-ലെ ഒരു ഫ്ലാഗ് വഴിയാണ് സൂചിപ്പിക്കുന്നത്).

ഈ ഫംഗ്‌ഷൻ "$x+1" പോലുള്ള പരിഷ്‌ക്കരിക്കാനാവാത്ത കാര്യങ്ങൾ കണ്ടെത്തി ജനറേറ്റുചെയ്യുന്നു
അവർക്ക് തെറ്റുകൾ. ഉദാഹരണത്തിന്, "$x+1 = 2" എന്നത് ഒരു op ഉപയോഗിച്ച് വിളിക്കപ്പെടുന്നതിന് കാരണമാകും
OP_ADD തരവും OP_SASSIGN എന്ന "തരം" ആർഗ്യുമെന്റും.

ഒരു മൂല്യബോധമുള്ള സന്ദർഭത്തിൽ പ്രത്യേകമായി പെരുമാറേണ്ട കാര്യങ്ങളും ഇത് ഫ്ലാഗ് ചെയ്യുന്നു
"$$x = 5", അത് $x-ൽ ഒരു റഫറൻസ് സജീവമാക്കേണ്ടതുണ്ട്.

OP * op_lvalue (OP *o, I32 തരം)

OP_NAME നൽകിയിരിക്കുന്ന OP യുടെ പേര് തിരികെ നൽകുക. കോർ ഓപ്‌സിനായി ഇത് ഇതിൽ നിന്ന് പേര് നോക്കുന്നു
op_type; op_ppaddr-ൽ നിന്നുള്ള ഇഷ്‌ടാനുസൃത ഓപ്‌സിനായി.

കോൺസ്റ്റ് ചാർ * OP_NAME(OP *o)

op_null ഒരു op ആവശ്യമില്ലാത്തപ്പോൾ അത് നിർവീര്യമാക്കുന്നു, പക്ഷേ അത് ഇപ്പോഴും മറ്റുള്ളവയുമായി ലിങ്ക് ചെയ്‌തിരിക്കുന്നു
ops.

ശൂന്യമായ op_null(OP *o)

op_parent
രക്ഷിതാവുണ്ടെങ്കിൽ o യുടെ പാരന്റ് OP നൽകുന്നു. അല്ലാത്തപക്ഷം NULL നൽകുന്നു. ഈ
"-DPERL_OP_PARENT" ഉപയോഗിച്ച് നിർമ്മിച്ച പെർലുകളിൽ മാത്രമേ ഫംഗ്‌ഷൻ ലഭ്യമാകൂ.

OP* op_parent(OP *o)

op_prepend_elem
ഒരു ലിസ്റ്റ്-ടൈപ്പ് ഓപ്പിനുള്ളിൽ നേരിട്ട് അടങ്ങിയിരിക്കുന്ന ഒപ്‌സുകളുടെ ലിസ്റ്റിലേക്ക് ഒരു ഇനം മുൻകൈ എടുക്കുക,
നീട്ടിയ പട്ടിക തിരികെ നൽകുന്നു. ആദ്യം ലിസ്‌റ്റിലേക്ക് മുൻകൈയെടുക്കാനുള്ള ഓപ്‌ ആണ്, കൂടാതെ അവസാനത്തെ
ലിസ്റ്റ്-ടൈപ്പ് ഓപ് ആണ്. ഒപ്ടൈപ്പ് ലിസ്റ്റിനായി ഉദ്ദേശിക്കുന്ന ഒപ്‌കോഡ് വ്യക്തമാക്കുന്നു. എങ്കിൽ അവസാനത്തെ
ഇതിനകം ശരിയായ തരത്തിലുള്ള ഒരു ലിസ്റ്റ് അല്ല, അത് ഒന്നായി അപ്ഗ്രേഡ് ചെയ്യും. ഒന്നുകിൽ എങ്കിൽ
ആദ്യം or അവസാനത്തെ അസാധുവാണ്, മറ്റൊന്ന് മാറ്റമില്ലാതെ തിരികെ നൽകും.

OP * op_prepend_elem(I32 ഒപ്‌ടൈപ്പ്, OP *ആദ്യം, OP *അവസാനം)

op_scope
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ചില അധിക ഓപ്‌സുകൾ ഉപയോഗിച്ച് ഒരു ഓപ് ട്രീ പൊതിയുന്നു, അങ്ങനെ പ്രവർത്തനസമയത്ത് ഒരു ഡൈനാമിക് സ്കോപ്പ്
സൃഷ്ടിക്കപ്പെടും. യഥാർത്ഥ ഓപ്‌സ് പുതിയ ഡൈനാമിക് സ്കോപ്പിൽ പ്രവർത്തിക്കുന്നു, തുടർന്ന്,
അവ സാധാരണയായി പുറത്തുകടക്കുകയാണെങ്കിൽ, സ്കോപ്പ് അനാവരണം ചെയ്യപ്പെടും. അധിക ഓപ്‌സ്
ഡൈനാമിക് സ്‌കോപ്പ് സൃഷ്‌ടിക്കാനും അഴിച്ചുവിടാനും ഉപയോഗിക്കുന്നത് സാധാരണയായി ഒരു "എന്റർ"/"ലീവ്" ആയിരിക്കും.
ജോടി, എന്നാൽ ഓപ്‌സ് വേണ്ടത്ര ലളിതമാണെങ്കിൽ പകരം ഒരു "സ്കോപ്പ്" ഒപി ഉപയോഗിക്കാം
പൂർണ്ണ ഡൈനാമിക് സ്കോപ്പ് ഘടന ആവശ്യമാണ്.

OP * op_scope(OP *o)

op_sibling_splice
op_sibling-ന്റെ നിലവിലുള്ള ഒരു ശൃംഖലയുടെ ഘടന എഡിറ്റുചെയ്യുന്നതിനുള്ള ഒരു പൊതു പ്രവർത്തനം
നോഡുകൾ. പേൾ-ലെവലുമായുള്ള സാമ്യം വഴി സ്പ്ലൈസ്() ഫംഗ്ഷൻ, ഇല്ലാതാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു
പൂജ്യമോ അതിലധികമോ സീക്വൻഷ്യൽ നോഡുകൾ, അവയെ പൂജ്യമോ അതിലധികമോ വ്യത്യസ്ത നോഡുകൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു.
പാരന്റ് നോഡിൽ ആവശ്യമായ op_first/op_last ഹൗസ് കീപ്പിംഗ് നടത്തുന്നു
കുട്ടികളിൽ op_sibling കൃത്രിമത്വം. അവസാനം ഇല്ലാതാക്കിയ നോഡ് ഇതായി അടയാളപ്പെടുത്തും
op_sibling/op_sibparent അല്ലെങ്കിൽ op_moresib ഫീൽഡ് അപ്‌ഡേറ്റ് ചെയ്തുകൊണ്ട് അവസാന നോഡായി
ഉചിതമായത്.

ശ്രദ്ധിക്കുക, op_next കൃത്രിമമല്ല, കൂടാതെ നോഡുകൾ സ്വതന്ത്രവുമല്ല; അതാണ്
വിളിക്കുന്നയാളുടെ ഉത്തരവാദിത്തം. ശൂന്യമായ ഒരു ലിസ്‌റ്റ് ഓപ്‌സിനായി ഇത് സൃഷ്‌ടിക്കില്ല
പട്ടിക മുതലായവ; പോലുള്ള ഉയർന്ന തലത്തിലുള്ള പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കുക op_append_elem() അതിനു വേണ്ടി.

സഹോദര ശൃംഖലയുടെ പാരന്റ് നോഡാണ് പാരന്റ്. എങ്കിൽ NULL ആയി കടന്നുപോകാം
പിളർപ്പ് ശൃംഖലയിലെ ആദ്യത്തേയോ അവസാനത്തേയോ ഓപ്പിനെ ബാധിക്കില്ല.

സ്‌പ്ലൈസ് ചെയ്യേണ്ട ആദ്യത്തെ നോഡിന് മുമ്പുള്ള നോഡാണ് start. അതിനെ പിന്തുടരുന്ന നോഡ്(കൾ).
ഇല്ലാതാക്കപ്പെടും, അതിനു ശേഷം ops ചേർക്കും. NULL ആണെങ്കിൽ, ആദ്യത്തെ നോഡ്
മുന്നോട്ട് ഇല്ലാതാക്കി, തുടക്കത്തിൽ നോഡുകൾ ചേർക്കുന്നു.

ഇല്ലാതാക്കേണ്ട നോഡുകളുടെ എണ്ണമാണ് del_count. പൂജ്യമാണെങ്കിൽ, നോഡുകളൊന്നും ഇല്ലാതാക്കില്ല. എങ്കിൽ -1
അല്ലെങ്കിൽ ശേഷിക്കുന്ന കുട്ടികളുടെ എണ്ണത്തേക്കാൾ വലുതോ തുല്യമോ, ശേഷിക്കുന്ന എല്ലാ കുട്ടികളും
ഇല്ലാതാക്കി.

നോഡുകളുടെ സ്ഥാനത്ത് തിരുകേണ്ട നോഡുകളുടെ ഒരു ശൃംഖലയുടെ ആദ്യത്തേതാണ് insert. എങ്കിൽ
NULL, നോഡുകളൊന്നും ചേർത്തിട്ടില്ല.

ഇല്ലാതാക്കിയ ഓപ്‌സിന്റെ ശൃംഖലയുടെ തല തിരികെ നൽകും, അല്ലെങ്കിൽ ഓപ്‌സുകളൊന്നും ഇല്ലാതാക്കിയില്ലെങ്കിൽ NULL.

ഉദാഹരണത്തിന്:

മടങ്ങിവരുന്നതിന് മുമ്പുള്ള നടപടി
------ ----- ------- -------

പി.പി.
splice(P, A, 2, XYZ) | | ബി.സി
ABCD AXYZD

പി.പി.
splice(P, NULL, 1, XY) | | എ
ABCD XYBCD

പി.പി.
splice(P, NULL, 3, NULL) | | എബിസി
എബിസിഡി ഡി

പി.പി.
splice(P, B, 0, XY) | | ശൂന്യം
ABCD ABXYCD

"op_sibparent", "op_moresib" എന്നിവയുടെ ലോവർ ലെവൽ ഡയറക്ട് കൃത്രിമത്വത്തിന്, കാണുക
"OpMORESIB_set", "OpLASTSIB_set", "OpMAYBESIB_set".

OP* op_sibling_splice(OP *പാരന്റ്, OP *ആരംഭം,
int del_count, OP* ഇൻസേർട്ട്)

OP_TYPE_IS
തന്നിരിക്കുന്ന OP ഒരു NULL പോയിന്ററല്ലെങ്കിൽ അത് തന്നിരിക്കുന്ന തരത്തിലാണെങ്കിൽ ശരി എന്ന് നൽകുന്നു.

"OP_TYPE_ISNT" എന്ന ഈ മാക്രോയുടെ നിഷേധവും ലഭ്യമാണ്
NULL പോയിന്റർ പരിശോധന ഒഴിവാക്കുന്ന "OP_TYPE_IS_NN", "OP_TYPE_ISNT_NN" എന്നിവ.

bool OP_TYPE_IS(OP *o, Optype തരം)

OP_TYPE_IS_OR_WAS
തന്നിരിക്കുന്ന OP ഒരു NULL പോയിന്ററല്ലെങ്കിൽ അത് തന്നിരിക്കുന്ന തരത്തിലാണെങ്കിൽ ശരി എന്ന് നൽകുന്നു
അല്ലെങ്കിൽ OP_NULL എന്ന തരത്തിലുള്ള OP ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നതിന് മുമ്പ് ഉപയോഗിച്ചിരുന്നു.

"OP_TYPE_ISNT_AND_WASNT" എന്ന ഈ മാക്രോയുടെ നിഷേധവും ലഭ്യമാണ്.
"OP_TYPE_IS_OR_WAS_NN", "OP_TYPE_ISNT_AND_WASNT_NN" എന്നിവ NULL-നെ പുറന്തള്ളുന്നു
പോയിന്റർ പരിശോധന.

bool OP_TYPE_IS_OR_WAS(OP *o, Optype തരം)

rv2cv_op_cv
റൺടൈമിൽ ഒരു സബ്റൂട്ടീൻ തിരിച്ചറിയുമെന്ന് പ്രതീക്ഷിക്കുന്ന ഒരു ഓപ് പരിശോധിക്കുന്നു, കൂടാതെ
ഏത് സബ്റൂട്ടിനെയാണ് ഇത് തിരിച്ചറിയുന്നതെന്ന് കംപൈൽ സമയത്ത് നിർണ്ണയിക്കാൻ ശ്രമിക്കുന്നു. ഇതാണ്
ഒരു പ്രോട്ടോടൈപ്പ് സാധ്യമാണോ എന്ന് നിർണ്ണയിക്കാൻ സാധാരണയായി പേൾ സമാഹരണ സമയത്ത് ഉപയോഗിക്കുന്നു
ഒരു ഫംഗ്‌ഷൻ കോളിലേക്ക് പ്രയോഗിച്ചു. cvop ഓപ് ആണ് പരിഗണിക്കുന്നത്, സാധാരണയായി ഒരു "rv2cv"
op. തിരിച്ചറിഞ്ഞ സബ്റൂട്ടീനിലേക്ക് ഒരു പോയിന്റർ തിരികെ നൽകും, അത് നിർണ്ണയിക്കാൻ കഴിയുമെങ്കിൽ
സ്ഥിരമായി, നിർണ്ണയിക്കാൻ സാധ്യമല്ലെങ്കിൽ ഒരു നൾ പോയിന്റർ തിരികെ നൽകും
സ്ഥിരമായി.

നിലവിൽ, "rv2cv" എന്ന RV ആണെങ്കിൽ സബ്റൂട്ടിനെ സ്ഥിരമായി തിരിച്ചറിയാൻ കഴിയും.
പ്രവർത്തിക്കേണ്ടത് അനുയോജ്യമായ "gv" അല്ലെങ്കിൽ "const" op ആണ് നൽകുന്നത്. ഒരു "ജിവി" ഓപ് ആണ്
ജിവിയുടെ സിവി സ്ലോട്ട് ജനസംഖ്യയുള്ളതാണെങ്കിൽ അനുയോജ്യം. എങ്കിൽ ഒരു "const" op അനുയോജ്യമാണ്
സ്ഥിരമായ മൂല്യം ഒരു സിവിയിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്ന ഒരു ആർവി ആയിരിക്കണം. ഈ പ്രക്രിയയുടെ വിശദാംശങ്ങൾ മാറിയേക്കാം
Perl-ന്റെ ഭാവി പതിപ്പുകളിൽ. "rv2cv" op-ന് "OPpENTERSUB_AMPER" ഫ്ലാഗ് ഉണ്ടെങ്കിൽ
സജ്ജീകരിച്ച ശേഷം, സബ്റൂട്ടീനെ സ്ഥിരമായി തിരിച്ചറിയാൻ ഒരു ശ്രമവും നടക്കുന്നില്ല: ഇതാണ് ഫ്ലാഗ്
ഒരു സബ്റൂട്ടീൻ കോളിൽ കംപൈൽ-ടൈം മാജിക് അടിച്ചമർത്താൻ ഉപയോഗിക്കുന്നു, അത് ഉപയോഗിക്കാൻ നിർബന്ധിതനായി
ഡിഫോൾട്ട് റൺടൈം പെരുമാറ്റം.

If ഫ്ലാഗുകൾ "RV2CVOPCV_MARK_EARLY" എന്ന ബിറ്റ് സജ്ജീകരിച്ചിരിക്കുന്നു, തുടർന്ന് ഒരു ജിവി കൈകാര്യം ചെയ്യുന്നു
റഫറൻസ് പരിഷ്കരിച്ചു. ഒരു ജിവി പരിശോധിച്ച് അതിന്റെ സിവി സ്ലോട്ട് കണ്ടെത്തിയാൽ
ശൂന്യമാണ്, തുടർന്ന് "gv" op-ന് "OPpEARLY_CV" ഫ്ലാഗ് സെറ്റ് ഉണ്ട്. ഒപി ഇല്ലെങ്കിൽ
ഒപ്റ്റിമൈസ് ചെയ്തു
പ്രോട്ടോടൈപ്പ്, ആ പതാക ഒടുവിൽ മുന്നറിയിപ്പ് ട്രിഗർ ചെയ്യുന്നു "പരിശോധിക്കാൻ വളരെ നേരത്തെ വിളിച്ചു
പ്രോട്ടോടൈപ്പ്".

If ഫ്ലാഗുകൾ "RV2CVOPCV_RETURN_NAME_GV" എന്ന ബിറ്റ് സജ്ജീകരിച്ചിരിക്കുന്നു, പിന്നീട് തിരികെ നൽകുന്നതിനുപകരം
സബ്റൂട്ടീനിലേക്കുള്ള പോയിന്റർ അത് ഏറ്റവും കൂടുതൽ നൽകുന്ന ജിവിയിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു
ഈ സന്ദർഭത്തിൽ സബ്റൂട്ടീന് അനുയോജ്യമായ പേര്. സാധാരണയായി ഇത് വെറും ആണ്
സബ്റൂട്ടീന്റെ "CvGV", എന്നാൽ ഒരു അജ്ഞാത ("CvANON") സബ്റൂട്ടീന്
ഒരു ജിവിയിലൂടെ പരാമർശിച്ചാൽ അത് റഫറൻസിങ് ജിവി ആയിരിക്കും. തത്ഫലമായുണ്ടാകുന്ന "GV*" ആണ്
തിരികെ നൽകുന്നതിന് "CV*" ലേക്ക് കാസ്‌റ്റ് ചെയ്യുക. ഒരു നൾ പോയിന്റർ ഇല്ലെങ്കിൽ സാധാരണ പോലെ തിരികെ നൽകും
സ്ഥിരമായി നിർണ്ണയിക്കാവുന്ന സബ്റൂട്ടീൻ.

CV * rv2cv_op_cv(OP *cvop, U32 ഫ്ലാഗുകൾ)

കെട്ടാക്കുക ഒപ്പം അൺപാക്ക് ചെയ്യുക

പാക്ക്ലിസ്റ്റ്
എഞ്ചിൻ നടപ്പിലാക്കുന്നു പാക്ക് () പേൾ പ്രവർത്തനം.

അസാധുവായ പാക്ക്‌ലിസ്റ്റ് (എസ്‌വി *പൂച്ച, കോൺസ്റ്റ് ചാർ *പാറ്റ്,
const char *patend, SV **beglist,
SV **അവസാന പട്ടിക)

അൺപാക്ക്സ്ട്രിംഗ്
നടപ്പിലാക്കുന്ന എഞ്ചിൻ അൺപാക്ക്() പേൾ പ്രവർത്തനം.

pat..patend എന്ന ടെംപ്ലേറ്റ് ഉപയോഗിച്ച്, ഈ ഫംഗ്ഷൻ സ്ട്രിംഗ് s..strend-ലേക്ക് അൺപാക്ക് ചെയ്യുന്നു.
മോർട്ടൽ എസ്വികളുടെ എണ്ണം, അത് പേൾ ആർഗ്യുമെന്റ് (@_) സ്റ്റാക്കിലേക്ക് തള്ളുന്നു (അതിനാൽ നിങ്ങൾ
ഇതിലേക്കുള്ള കോളിന് മുമ്പായി "പുട്ട്ബാക്ക്" ഇഷ്യൂ ചെയ്യേണ്ടതുണ്ട്
പ്രവർത്തനം). ഇത് തള്ളപ്പെട്ട മൂലകങ്ങളുടെ എണ്ണം നൽകുന്നു.

സ്ട്രെൻഡും പേറ്റന്റ് പോയിന്ററുകളും അവസാനത്തേതിന് ശേഷമുള്ള ബൈറ്റിലേക്ക് പോയിന്റ് ചെയ്യണം
ഓരോ സ്ട്രിംഗിന്റെയും സ്വഭാവം.

ഈ ഫംഗ്‌ഷൻ അതിന്റെ മൂല്യങ്ങൾ perl ആർഗ്യുമെന്റ് സ്റ്റാക്കിൽ നൽകുന്നുവെങ്കിലും, അത് നൽകുന്നില്ല
ആ സ്റ്റാക്കിൽ നിന്ന് ഏതെങ്കിലും പാരാമീറ്ററുകൾ എടുക്കുക (അതിനാൽ പ്രത്യേകിച്ച് ചെയ്യേണ്ട ആവശ്യമില്ല
വിളിക്കുന്നതിന് മുമ്പ് ഒരു പുഷ്‌മാർക്ക്, ഉദാഹരണത്തിന് "call_pv" പോലെയല്ല).

I32 unpackstring(const char *pat,
const char *patend, const char *s,
കോൺസ്റ്റ് ചാർ *സ്ട്രെൻഡ്, U32 ഫ്ലാഗുകൾ)

പാഡ് ഡാറ്റ ഘടനകൾ

CvPADLIST
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

CV-കൾക്ക് ഒരു PADLIST-ലേക്ക് പോയിന്റ് ചെയ്യാൻ CvPADLIST(cv) സജ്ജമാക്കാം. ഇതാണ് സിവി
സ്ക്രാച്ച്പാഡ്, ഇത് ലെക്സിക്കൽ വേരിയബിളുകളും ഓപ്കോഡും താൽക്കാലികവും ഓരോ ത്രെഡും സംഭരിക്കുന്നു
മൂല്യങ്ങൾ.

ഈ ആവശ്യങ്ങൾക്ക് "ഫോർമാറ്റുകൾ" ഒരു തരത്തിലുള്ള CV ആണ്; eval""കളും ഉണ്ട് (അതൊഴിച്ചാൽ
ഇഷ്ടാനുസരണം വിളിക്കാം, എവൽ"" നിർവ്വഹിച്ചതിന് ശേഷം എപ്പോഴും വലിച്ചെറിയപ്പെടും).
ആവശ്യമായ ഫയലുകൾ ബാഹ്യ ലെക്‌സിക്കൽ സ്കോപ്പില്ലാതെ ലളിതമായി ഇവലുകളാണ്.

XSUB-കൾക്ക് ഒരു CvPADLIST ഇല്ല. dXSTARG PL_curpad-ൽ നിന്ന് മൂല്യങ്ങൾ ലഭ്യമാക്കുന്നു, എന്നാൽ അതാണ്
ശരിക്കും കോളേഴ്‌സ് പാഡ് (എല്ലാ എന്റർസബും അനുവദിച്ച സ്ലോട്ട്). അരുത്
CV XSUB ആണെങ്കിൽ ("CvISXSUB()" നിർണ്ണയിക്കുന്നത് പോലെ), CvPADLIST നേടുക അല്ലെങ്കിൽ സജ്ജമാക്കുക
XSUB-കളിൽ മറ്റൊരു ആന്തരിക ആവശ്യത്തിനായി സ്ലോട്ട് വീണ്ടും ഉപയോഗിക്കുന്നു.

PADLIST-ന് പാഡുകൾ സൂക്ഷിക്കുന്ന ഒരു C അറേ ഉണ്ട്.

PADLIST-ന്റെ 0-ാമത്തെ എൻട്രി "പേരുകൾ" അല്ലെങ്കിൽ
പകരം ലെക്സിക്കലുകൾക്കുള്ള "സ്റ്റാറ്റിക് തരം വിവരങ്ങൾ". a യുടെ വ്യക്തിഗത ഘടകങ്ങൾ
PADNAMELIST എന്നത് PADNAME ആണ്. ഭാവിയിലെ റീഫാക്‌ടറിംഗുകൾ PADNAMELIST-നെ നിർത്തിയേക്കാം
PADLIST ന്റെ അറേയിൽ സംഭരിച്ചിരിക്കുന്നു, അതിനാൽ അതിൽ ആശ്രയിക്കരുത്. "PadlistNAMES" കാണുക.

ഒരു PADLIST-ന്റെ CvDEPTH-ന്റെ എൻട്രി ഒരു PAD (ഒരു AV) ആണ്, ഇത് സ്റ്റാക്ക് ഫ്രെയിം ആണ്
CV-യിലേക്കുള്ള ആവർത്തനത്തിന്റെ ആഴം. ഒരു ഫ്രെയിം AV-യുടെ 0-ാമത്തെ സ്ലോട്ട് ഒരു AV ആണ്
@_. വേരിയബിളുകൾക്കും ഓപ് ടാർഗെറ്റുകൾക്കുമുള്ള സംഭരണമാണ് മറ്റ് എൻട്രികൾ.

PADNAMELIST വഴി ആവർത്തിക്കുന്നത് സാധ്യമായ എല്ലാ പാഡ് ഇനങ്ങളിലും ആവർത്തിക്കുന്നു. പാഡ് സ്ലോട്ടുകൾ
ടാർഗെറ്റുകൾക്കും (SVs_PADTMP) ജിവികൾക്കും &PL_padname_undef "പേരുകൾ" ഉണ്ടായിരിക്കും, അതേസമയം
സ്ഥിരാങ്കങ്ങൾക്കുള്ള സ്ലോട്ടുകൾക്ക് &PL_padname_const "പേരുകൾ" ഉണ്ട് (കാണുക pad_alloc()). അത്
&PL_padname_undef, &PL_padname_const എന്നിവ ഉപയോഗിക്കുന്നത് ഒരു നടപ്പാക്കൽ വിശദാംശമാണ്
മാറ്റത്തിന് വിധേയമാണ്. അവ പരിശോധിക്കുന്നതിന്, "!PadnamePV(name)", "PadnamePV(name) എന്നിവ ഉപയോഗിക്കുക
&& !PadnameLEN(പേര്)", യഥാക്രമം.

എന്റെ/ഞങ്ങളുടെ വേരിയബിൾ സ്ലോട്ടുകൾക്ക് മാത്രമേ സാധുവായ പേരുകൾ ലഭിക്കൂ. ബാക്കിയുള്ളവ ഓപ് ടാർഗെറ്റുകൾ/ജിവികൾ/സ്ഥിരതകളാണ്
കംപൈൽ സമയത്ത് സ്ഥിരമായി അനുവദിച്ചിരിക്കുന്നതോ പരിഹരിക്കപ്പെട്ടതോ ആയവ. ഇവയില്ല
eval"" വഴി റൺ ടൈമിൽ പേൾ കോഡിൽ നിന്ന് നോക്കാൻ കഴിയുന്ന പേരുകൾ
എന്റെ/ഞങ്ങളുടെ വേരിയബിളുകൾ ആകാം. കാരണം, "പേര്" കൊണ്ട് അവരെ നോക്കാൻ കഴിയില്ല, അല്ലാതെ മാത്രം
അവയുടെ സൂചിക കംപൈൽ സമയത്ത് അനുവദിച്ചിരിക്കുന്നു (ഇത് സാധാരണയായി PL_op->op_targ-ലാണ്),
അവർക്കായി എസ് വി എന്ന പേര് പാഴാക്കുന്നതിൽ അർത്ഥമില്ല.

PADNAMELIST-ലെ പാഡ് നാമങ്ങൾക്ക് വേരിയബിളിന്റെ പേര് കൈവശമുള്ള PV ഉണ്ട്.
COP_SEQ_RANGE_LOW, _HIGH എന്നീ ഫീൽഡുകൾ ഒരു ശ്രേണി രൂപപ്പെടുത്തുന്നു (കുറഞ്ഞ+1.. ഉയർന്നത് ഉൾപ്പെടെ)
പേര് സാധുതയുള്ള cop_seq നമ്പറുകൾ. സമാഹരിക്കുന്ന സമയത്ത്, ഈ ഫീൽഡുകൾ ഉണ്ടാകാം
വിവിധ ഘട്ടങ്ങൾ സൂചിപ്പിക്കാൻ പ്രത്യേക മൂല്യം PERL_PADSEQ_INTRO പിടിക്കുക:

COP_SEQ_RANGE_LOW _HIGH
-------------------------
PERL_PADSEQ_INTRO 0 വേരിയബിൾ ഇതുവരെ അവതരിപ്പിച്ചിട്ടില്ല:
{എന്റെ ($x
Valid-seq# PERL_PADSEQ_INTRO വേരിയബിൾ പരിധിയിൽ:
{എന്റെ ($x)
Valid-seq# valid-seq# സ്കോപ്പിന്റെ സമാഹാരം പൂർത്തിയായി:
{എന്റെ ($x)}

ടൈപ്പ് ചെയ്‌ത ലെക്‌സിക്കലുകൾക്ക് PadnameTYPE പോയിന്റുകൾ ടൈപ്പ് സ്റ്റാഷിൽ. "നമ്മുടെ" ലെക്സിക്കലുകൾക്ക്,
PadnameOURSTASH ബന്ധപ്പെട്ട ഗ്ലോബലിന്റെ സ്‌റ്റാഷിലേക്ക് പോയിന്റ് ചെയ്യുന്നു (അതിനാൽ ഡ്യൂപ്ലിക്കേറ്റ്
ഒരേ പാക്കേജിലെ "ഞങ്ങളുടെ" പ്രഖ്യാപനങ്ങൾ കണ്ടെത്താനാകും). PadnameGEN ചിലപ്പോൾ
കംപൈലേഷൻ സമയത്ത് ജനറേഷൻ നമ്പർ സൂക്ഷിക്കാൻ ഉപയോഗിക്കുന്നു.

പാഡ് നാമത്തിൽ PadnameOUTER സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, AV ഫ്രെയിമിലെ സ്ലോട്ട് a ആണ്
"പുറത്ത്" നിന്നുള്ള ഒരു ലെക്‌സിക്കലിനെക്കുറിച്ചുള്ള REFCNT റഫറൻസ്. അത്തരം എൻട്രികൾ ചിലപ്പോൾ
'വ്യാജം' എന്ന് പരാമർശിക്കുന്നു. ഈ സാഹചര്യത്തിൽ, പേര് 'താഴ്ന്നത്', 'ഉയരം' എന്നിവ ഉപയോഗിക്കുന്നില്ല
ഒരു cop_seq ശ്രേണി സംഭരിക്കുക, കാരണം അത് ഉടനീളം വ്യാപ്തിയുള്ളതാണ്. പകരം 'ഉയർന്ന' സ്റ്റോറുകൾ
യഥാർത്ഥ ലെക്സിക്കലിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ അടങ്ങിയ ചില ഫ്ലാഗുകൾ (അത് ഒരു അനോണിൽ പ്രഖ്യാപിച്ചിട്ടുണ്ടോ, കൂടാതെ
ഇത് ഒന്നിലധികം തവണ തൽക്ഷണം ചെയ്യാൻ പ്രാപ്തമാണോ?), കൂടാതെ വ്യാജ ANON-കൾക്ക് 'കുറഞ്ഞത്'
ലെക്സിക്കലിന്റെ മൂല്യം സംഭരിച്ചിരിക്കുന്ന രക്ഷാകർതൃ പാഡിനുള്ളിലെ സൂചിക അടങ്ങിയിരിക്കുന്നു
ക്ലോണിംഗ് വേഗത്തിലാക്കുക.

'പേര്' '&' ആണെങ്കിൽ, PAD-ലെ അനുബന്ധ എൻട്രി ഒരു CV ആണ്
സാധ്യമായ അടച്ചുപൂട്ടൽ.

ഫോർമാറ്റുകൾ അനോൺ സബ്‌സ് ആയി കണക്കാക്കുന്നു, ഓരോ തവണ എഴുതുമ്പോഴും ക്ലോൺ ചെയ്യപ്പെടുന്നു
വിളിച്ചു (ആവശ്യമെങ്കിൽ).

ഓരോ തവണയും ലെക്സിക്കലുകളിൽ SVs_PADSTALE എന്ന ഫ്ലാഗ് മായ്‌ക്കപ്പെടുന്നു ente() നിർവ്വഹിക്കുന്നു, ഒപ്പം
സ്കോപ്പ് എക്സിറ്റിൽ സജ്ജമാക്കി. 'വേരിയബിൾ $x ലഭ്യമല്ല' എന്ന മുന്നറിയിപ്പ് നൽകാൻ ഇത് അനുവദിക്കുന്നു
പോലുള്ള eval-ൽ സൃഷ്ടിച്ചത്

{എന്റെ $x = 1; ഉപ f { eval '$x'} } f();

സംസ്ഥാന vars-ന്, SVs_PADSTALE ഓവർലോഡ് ചെയ്‌തിരിക്കുന്നു, 'ഇതുവരെ ആരംഭിച്ചിട്ടില്ല' എന്നാണ് അർത്ഥമാക്കുന്നത്, എന്നാൽ ഇത്
ആന്തരിക അവസ്ഥ ഒരു പ്രത്യേക പാഡ് എൻട്രിയിൽ സംഭരിച്ചിരിക്കുന്നു.

പാഡ്‌ലിസ്റ്റ് * CvPADLIST(CV *cv)

പദാർരേ
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

പാഡ് എൻട്രികളുടെ സി അറേ.

SV ** PadARRAY(PAD പാഡ്)

പാഡ്‌ലിസ്റ്റ്ARRAY
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

പാഡുകൾ അടങ്ങുന്ന ഒരു പാഡ്‌ലിസ്റ്റിന്റെ സി അറേ. >= എന്ന നമ്പറിൽ മാത്രം സബ്‌സ്‌ക്രിപ്റ്റ് ചെയ്യുക
1, 0-ാമത്തെ എൻട്രി ഉപയോഗയോഗ്യമായി തുടരുമെന്ന് ഉറപ്പില്ല.

PAD ** PadlistARRAY(PADLIST പാഡ്‌ലിസ്റ്റ്)

PadlistMAX
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

പാഡ്‌ലിസ്റ്റിൽ അവസാനം അനുവദിച്ച സ്ഥലത്തിന്റെ സൂചിക. അവസാന പാഡ് ആയിരിക്കാം എന്നത് ശ്രദ്ധിക്കുക
നേരത്തെയുള്ള സ്ലോട്ടിൽ ആയിരിക്കുക. അതിനെ തുടർന്നുള്ള എല്ലാ എൻട്രികളും ആ സാഹചര്യത്തിൽ NULL ആയിരിക്കും.

SSize_t PadlistMAX(PADLIST പാഡ്‌ലിസ്റ്റ്)

PadlistNAMES
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

പാഡ് എൻട്രികളുമായി ബന്ധപ്പെട്ട പേരുകൾ.

PADNAMELIST * PadlistNAMES(PADLIST പാഡ്‌ലിസ്റ്റ്)

പാഡ്‌ലിസ്റ്റ്NAMESARRAY
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

പാഡ് നാമങ്ങളുടെ സി നിര.

പാഡ്‌നാമം ** പാഡ്‌ലിസ്റ്റ്NAMESARRAY(പാഡ്‌ലിസ്റ്റ് പാഡ്‌ലിസ്റ്റ്)

PadlistNAMESMAX
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

അവസാന പാഡ് നാമത്തിന്റെ സൂചിക.

SSize_t PadlistNAMESMAX(PADLIST പാഡ്‌ലിസ്റ്റ്)

പാഡ്‌ലിസ്റ്റ്REFCNT
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

പാഡ്‌ലിസ്റ്റിന്റെ റഫറൻസ് എണ്ണം. നിലവിൽ ഇത് എല്ലായ്പ്പോഴും 1 ആണ്.

U32 PadlistREFCNT(PADLIST പാഡ്‌ലിസ്റ്റ്)

PadMAX കുറിപ്പ്: ഈ പ്രവർത്തനം പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

അവസാന പാഡ് എൻട്രിയുടെ സൂചിക.

SSize_t PadMAX(PAD പാഡ്)

PadnameLEN
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

പേരിന്റെ നീളം.

STRLEN PadnameLEN(PADNAME pn)

പാഡ്നാമലിസ്റ്റ്ARRAY
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

പാഡ് നാമങ്ങളുടെ സി നിര.

PADNAME ** PadnamelistARRAY(PADNAMELIST pnl)

പാഡ്‌നാമലിസ്റ്റ്MAX
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

അവസാന പാഡ് നാമത്തിന്റെ സൂചിക.

SSize_t പാഡ്‌നാമലിസ്റ്റ്MAX(PADNAMELIST pnl)

പാഡ്നാമലിസ്റ്റ്REFCNT
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

പാഡ് നെയിം ലിസ്റ്റിന്റെ റഫറൻസ് എണ്ണം.

SSize_t പാഡ്‌നാമലിസ്റ്റ്REFCNT(PADNAMELIST pnl)

പാഡ്‌നാമലിസ്റ്റ്REFCNT_dec
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

പാഡ് നെയിം ലിസ്റ്റിന്റെ റഫറൻസ് എണ്ണം കുറയ്ക്കുന്നു.

അസാധുവായ PadnamelistREFCNT_dec(PADNAMELIST pnl)

പദ്നാമംPV
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

പാഡ് നെയിം സ്‌ട്രക്‌റ്റിൽ സംഭരിച്ചിരിക്കുന്ന പേര്. ഇത് ഒരു ടാർഗെറ്റ് സ്ലോട്ടിന് NULL നൽകുന്നു.

char * PadnamePV(PADNAME pn)

പാഡ്‌നാമംREFCNT
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

പാഡ് നാമത്തിന്റെ റഫറൻസ് എണ്ണം.

SSize_t പാഡ്‌നാമംREFCNT(PADNAME pn)

പാഡ്‌നാമംREFCNT_dec
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

പാഡ് നാമത്തിന്റെ റഫറൻസ് എണ്ണം കുറയ്ക്കുന്നു.

അസാധുവായ PadnameREFCNT_dec(PADNAME pn)

PadnameSV
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു മോർട്ടൽ SV ആയി പാഡ് നാമം നൽകുന്നു.

SV * PadnameSV(PADNAME pn)

പാഡ്‌നാമംUTF8
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

PadnamePV UTF8-ൽ ഉണ്ടോ എന്ന്. നിലവിൽ, ഇത് എല്ലായ്പ്പോഴും ശരിയാണ്.

bool PadnameUTF8(PADNAME pn)

pad_add_name_pvs
കൃത്യമായി "pad_add_name_pvn" പോലെയാണ്, എന്നാൽ a എന്നതിന് പകരം ഒരു ലിറ്ററൽ സ്ട്രിംഗ് എടുക്കുന്നു
സ്ട്രിംഗ്/നീളം ജോടി.

PADOFFSET pad_add_name_pvs(const char *name, U32 ഫ്ലാഗുകൾ,
HV *typestash, HV *ourstash)

pad_findmy_pvs
കൃത്യമായി "pad_findmy_pvn" പോലെയാണ്, എന്നാൽ a എന്നതിന് പകരം ഒരു ലിറ്ററൽ സ്ട്രിംഗ് എടുക്കുന്നു
സ്ട്രിംഗ്/നീളം ജോടി.

PADOFFSET pad_findmy_pvs(const char *name, U32 ഫ്ലാഗുകൾ)

pad_new ഒരു പുതിയ പാഡ്‌ലിസ്റ്റ് സൃഷ്‌ടിക്കുക, നിലവിൽ കംപൈലിങ്ങിന് ആഗോള വേരിയബിളുകൾ അപ്‌ഡേറ്റ് ചെയ്യുക
പുതിയ പാഡ്‌ലിസ്റ്റിലേക്ക് ചൂണ്ടിക്കാണിക്കാൻ പാഡ്‌ലിസ്റ്റ്. ഇനിപ്പറയുന്ന ഫ്ലാഗുകൾ ഒരുമിച്ച് ചേർക്കാം:

padnew_CLONE ഈ പാഡ് ഒരു ക്ലോൺ ചെയ്ത CV ക്കുള്ളതാണ്
padnew_SAVE സേവ് സ്റ്റാക്കിൽ പഴയ ഗ്ലോബലുകൾ സംരക്ഷിക്കുക
padnew_SAVESUB ഉപയുടെ ആരംഭത്തിനായി അധിക സാധനങ്ങളും സംരക്ഷിക്കുക

PADLIST * pad_new(int ഫ്ലാഗുകൾ)

PL_compad
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

സമാഹരിക്കുന്ന സമയത്ത്, ഇത് പാഡിന്റെ മൂല്യങ്ങൾ ഉൾക്കൊള്ളുന്ന അറേയെ സൂചിപ്പിക്കുന്നു
നിലവിൽ കംപൈൽ ചെയ്യുന്ന കോഡിനായി. (റൺടൈമിൽ ഒരു സിവിക്ക് അത്തരം നിരവധി മൂല്യങ്ങൾ ഉണ്ടായിരിക്കാം
അറേകൾ; കംപൈൽ സമയത്ത് ഒരെണ്ണം മാത്രമേ നിർമ്മിച്ചിട്ടുള്ളൂ.) റൺടൈമിൽ, ഇത് ചൂണ്ടിക്കാണിക്കുന്നു
നിലവിൽ-പാഡിനുള്ള നിലവിലെ പ്രസക്തമായ മൂല്യങ്ങൾ അടങ്ങുന്ന അറേ-
കോഡ് നടപ്പിലാക്കുന്നു.

PL_compad_name
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

സമാഹരിക്കുന്ന സമയത്ത്, ഇത് പാഡിന്റെ ഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്ന അറേയെ സൂചിപ്പിക്കുന്നു
നിലവിൽ കംപൈൽ ചെയ്യുന്ന കോഡിനായി.

PL_curpad
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

"PL_compad" അറേയുടെ ബോഡിയിലേക്ക് നേരിട്ട് പോയിന്റുകൾ. (അതായത്, ഇതാണ്
"PAD_ARRAY(PL_compad)".)

ഓരോ ഇന്റർപ്രെറ്റർ വേരിയബിളുകൾ

PL_modglobal
"PL_modglobal" എന്നത് ഒരു പൊതു ഉദ്ദേശ്യമാണ്, വിപുലീകരണങ്ങൾ ഉപയോഗിക്കുന്നതിനുള്ള ഇന്റർപ്രെറ്റർ ഗ്ലോബൽ HV ആണ്
ഓരോ വ്യാഖ്യാതാവിന്റെ അടിസ്ഥാനത്തിൽ വിവരങ്ങൾ സൂക്ഷിക്കേണ്ടതുണ്ട്. ഒരു നുള്ളിൽ, അതും കഴിയും
പരസ്പരം ഡാറ്റ പങ്കിടുന്നതിന് വിപുലീകരണങ്ങൾക്കായി ഒരു ചിഹ്ന പട്ടികയായി ഉപയോഗിക്കുന്നു. ഇത് എ
അതിന്റെ ഉടമസ്ഥതയിലുള്ള വിപുലീകരണത്തിന്റെ പാക്കേജ് നാമം പ്രിഫിക്സ് ചെയ്ത കീകൾ ഉപയോഗിക്കുന്നത് നല്ലതാണ്
ഡാറ്റ.

HV* PL_modglobal

PL_na ഒരാൾ ശ്രദ്ധിക്കാത്തപ്പോൾ "SvPV" ഉപയോഗിച്ച് സാധാരണയായി ഉപയോഗിക്കുന്ന ഒരു കൺവീനിയൻസ് വേരിയബിൾ
ചരടിന്റെ നീളത്തെക്കുറിച്ച്. എ പ്രഖ്യാപിക്കുന്നത് സാധാരണയായി കൂടുതൽ കാര്യക്ഷമമാണ്
ലോക്കൽ വേരിയബിൾ പകരം അത് ഉപയോഗിക്കുക അല്ലെങ്കിൽ "SvPV_nolen" മാക്രോ ഉപയോഗിക്കുക.

STRLEN PL_na

PL_opfreehook
"NULL" അല്ലാത്തപ്പോൾ, ഈ വേരിയബിൾ ചൂണ്ടിക്കാണിക്കുന്ന ഫംഗ്‌ഷനെ ഓരോ തവണയും വിളിക്കും a
അനുബന്ധ OP വാദമായി ഉപയോഗിച്ച് OP സ്വതന്ത്രമാകുന്നു. ഇത് വിപുലീകരണങ്ങളെ അനുവദിക്കുന്നു
ഒരു OP-യിൽ അവർ പ്രാദേശികമായി ഘടിപ്പിച്ചിട്ടുള്ള ഏതെങ്കിലും അധിക ആട്രിബ്യൂട്ട് സൗജന്യമാക്കുക. അതും ഉറപ്പ്
ആദ്യം പാരന്റ് ഒപിക്കും പിന്നെ അതിന്റെ കുട്ടികൾക്കും വേണ്ടി തീയിടുക.

നിങ്ങൾ ഈ വേരിയബിൾ മാറ്റിസ്ഥാപിക്കുമ്പോൾ, സംഭരിക്കുന്നത് ഒരു നല്ല പരിശീലനമായി കണക്കാക്കപ്പെടുന്നു
ഒരുപക്ഷേ മുമ്പ് ഇൻസ്റ്റാൾ ചെയ്ത ഹുക്ക് നിങ്ങളുടെ സ്വന്തം ഉള്ളിൽ നിങ്ങൾ അത് ഓർക്കുന്നു.

Perl_ophook_t PL_opfreehook

PL_peepp
ഓരോ സബ്റൂട്ടൈൻ പീഫോൾ ഒപ്റ്റിമൈസറിലേക്കുള്ള പോയിന്റർ. ഇത് ലഭിക്കുന്ന ഒരു ഫംഗ്ഷനാണ്
ഒരു പേൾ സബ്റൂട്ടീന്റെ (അല്ലെങ്കിൽ തത്തുല്യമായ സ്വതന്ത്രമായ) സമാഹാരത്തിന്റെ അവസാനം വിളിക്കുന്നു
പേൾ കോഡിന്റെ കഷണം) ചില ഓപ്‌സുകളുടെ ഫിക്സപ്പുകൾ നടത്താനും ചെറിയ തോതിലുള്ള പ്രകടനം നടത്താനും
ഒപ്റ്റിമൈസേഷനുകൾ. കംപൈൽ ചെയ്ത ഓരോ സബ്റൂട്ടീനിനും ഫംഗ്ഷൻ ഒരിക്കൽ വിളിക്കപ്പെടുന്നു,
എൻട്രി പോയിന്റായ op-ലേക്കുള്ള ഒരു പോയിന്റർ എന്ന നിലയിൽ, ഏക പാരാമീറ്ററായി കടന്നുപോകുകയും ചെയ്യുന്നു
സബ്റൂട്ടീൻ. ഇത് ഓപ് ട്രീയെ മാറ്റുന്നു.

പീഫോൾ ഒപ്റ്റിമൈസർ ഒരിക്കലും പൂർണ്ണമായും മാറ്റിസ്ഥാപിക്കാൻ പാടില്ല. പകരം, കോഡ് ചേർക്കുക
നിലവിലുള്ള ഒപ്റ്റിമൈസർ പൊതിഞ്ഞ് അത്. ഇതിനുള്ള അടിസ്ഥാന മാർഗം ഇതിൽ കാണാം
പെർൽഗട്ടിൽ "കംപൈൽ പാസ് 3: പീഫോൾ ഒപ്റ്റിമൈസേഷൻ". പുതിയ കോഡ് ആഗ്രഹിക്കുന്നുവെങ്കിൽ
മുകളിൽ മാത്രമല്ല, സബ്റൂട്ടീന്റെ ഘടനയിലുടനീളം ഓപ്‌സിൽ പ്രവർത്തിക്കുക
ലെവൽ, "PL_rpeepp" ഹുക്ക് പൊതിയുന്നത് കൂടുതൽ സൗകര്യപ്രദമായിരിക്കും.

peep_t PL_peepp

PL_rpeepp
ആവർത്തന പീഫോൾ ഒപ്റ്റിമൈസറിലേക്കുള്ള പോയിന്റർ. ഇത് വിളിക്കപ്പെടുന്ന ഒരു ഫംഗ്ഷനാണ്
ഒരു പേൾ സബ്റൂട്ടീന്റെ സമാഹാരത്തിന്റെ അവസാനം (അല്ലെങ്കിൽ തത്തുല്യമായ സ്വതന്ത്ര ഭാഗം
പേൾ കോഡിന്റെ) ചില ഓപ്‌സുകളുടെ ഫിക്‌സപ്പുകൾ നടത്താനും ചെറിയ തോതിലുള്ള പ്രകടനം നടത്താനും
ഒപ്റ്റിമൈസേഷനുകൾ. ലിങ്ക് ചെയ്‌തിരിക്കുന്ന ഓപ്‌സിന്റെ ഓരോ ശൃംഖലയ്ക്കും ഒരിക്കൽ ഫംഗ്‌ഷൻ വിളിക്കുന്നു
അവരുടെ "op_next" ഫീൽഡുകൾ; ഓരോ സൈഡ് ചെയിൻ കൈകാര്യം ചെയ്യാൻ അതിനെ ആവർത്തനപരമായി വിളിക്കുന്നു. അത്
ഏക പാരാമീറ്ററായി കടന്നുപോയി, ചെയിനിന്റെ തലയിലുള്ള ഓപ്പിലേക്കുള്ള ഒരു പോയിന്റർ.
ഇത് ഓപ് ട്രീയെ മാറ്റുന്നു.

പീഫോൾ ഒപ്റ്റിമൈസർ ഒരിക്കലും പൂർണ്ണമായും മാറ്റിസ്ഥാപിക്കാൻ പാടില്ല. പകരം, കോഡ് ചേർക്കുക
നിലവിലുള്ള ഒപ്റ്റിമൈസർ പൊതിഞ്ഞ് അത്. ഇതിനുള്ള അടിസ്ഥാന മാർഗം ഇതിൽ കാണാം
പെർൽഗട്ടിൽ "കംപൈൽ പാസ് 3: പീഫോൾ ഒപ്റ്റിമൈസേഷൻ". പുതിയ കോഡ് ആഗ്രഹിക്കുന്നുവെങ്കിൽ
ഒരു സബ്റൂട്ടീന്റെ ടോപ്പ് ലെവലിലുള്ള ഓപ്‌സിൽ മാത്രം പ്രവർത്തിക്കുക
ഘടന, "PL_peepp" ഹുക്ക് പൊതിയുന്നത് കൂടുതൽ സൗകര്യപ്രദമായിരിക്കും.

peep_t PL_rpeepp

PL_sv_no
ഇതാണ് "തെറ്റായ" എസ്.വി. "PL_sv_yes" കാണുക. ഇത് എപ്പോഴും &PL_sv_no എന്ന് റഫർ ചെയ്യുക.

SV PL_sv_no

PL_sv_undef
ഇതാണ് "undef" SV. ഇത് എപ്പോഴും &PL_sv_undef എന്ന് റഫർ ചെയ്യുക.

SV PL_sv_undef

PL_sv_yes
ഇതാണ് "യഥാർത്ഥ" എസ്.വി. "PL_sv_no" കാണുക. ഇത് എപ്പോഴും &PL_sv_yes എന്ന് റഫർ ചെയ്യുക.

SV PL_sv_yes

REGEXP പ്രവർത്തനങ്ങൾ

ഒരു SV-ൽ നിന്ന് REGEXP ലഭിക്കാൻ SvRX കൺവീനിയൻസ് മാക്രോ. ഇത് ഏകദേശം തുല്യമാണ്
ഇനിപ്പറയുന്ന സ്‌നിപ്പെറ്റിലേക്ക്:

എങ്കിൽ (SvMAGICAL(sv))
mg_get(sv);
എങ്കിൽ (SvROK(sv))
sv = MUTABLE_SV(SvRV(sv));
എങ്കിൽ (SvTYPE(sv) == SVt_REGEXP)
റിട്ടേൺ (REGEXP*) sv;

ഒരു REGEXP* കണ്ടെത്തിയില്ലെങ്കിൽ NULL തിരികെ നൽകും.

REGEXP * SvRX(SV *sv)

SvRXOK SV (അല്ലെങ്കിൽ അത് റഫറൻസ് ചെയ്യുന്ന ഒന്ന്) ആണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു
REGEXP.

നിങ്ങൾക്ക് REGEXP* ഉപയോഗിച്ച് എന്തെങ്കിലും ചെയ്യാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, പകരം SvRX ഉപയോഗിച്ച് പരിശോധിക്കുക
ശൂന്യം.

bool SvRXOK(SV* sv)

കൂനകൂട്ടുക കൃത്രിമം മാക്രോകൾ

dMARK XSUB-നായി ഒരു സ്റ്റാക്ക് മാർക്കർ വേരിയബിൾ, "മാർക്ക്" പ്രഖ്യാപിക്കുക. "മാർക്ക്" കാണുക ഒപ്പം
"ഡോറിഗ്മാർക്ക്".

dMARK;

ഡോറിഗ്മാർക്ക്
XSUB-നുള്ള യഥാർത്ഥ സ്റ്റാക്ക് മാർക്ക് സംരക്ഷിക്കുന്നു. "ORIGMARK" കാണുക.

ഡോറിഗ്മാർക്ക്;

"SP" വഴി ലഭ്യമായ XSUB-നുള്ള perl-ന്റെ സ്റ്റാക്ക് പോയിന്ററിന്റെ ഒരു പ്രാദേശിക പകർപ്പ് dSP പ്രഖ്യാപിക്കുന്നു.
മാക്രോ. "SP" കാണുക.

ഡിഎസ്പി;

ഒരു XSUB-ന്റെ റിട്ടേൺ മൂല്യങ്ങൾക്കായി ആർഗ്യുമെന്റ് സ്റ്റാക്ക് വിപുലീകരിക്കാൻ EXTEND ഉപയോഗിക്കുന്നു. ഒരിക്കൽ ഉപയോഗിച്ചു,
കുറഞ്ഞത് "നൈറ്റങ്ങൾ" സ്റ്റാക്കിലേക്ക് തള്ളാൻ ഇടമുണ്ടെന്ന് ഉറപ്പ് നൽകുന്നു.

അസാധുവായ EXTEND(SP, SSize_t nitems)

XSUB-നുള്ള സ്റ്റാക്ക് മാർക്കർ വേരിയബിൾ അടയാളപ്പെടുത്തുക. "dMARK" കാണുക.

mPUSHi സ്റ്റാക്കിലേക്ക് ഒരു പൂർണ്ണസംഖ്യ തള്ളുക. സ്റ്റാക്കിൽ ഈ ഘടകത്തിന് ഇടം ഉണ്ടായിരിക്കണം. ചെയ്യുന്നു
"TARG" ഉപയോഗിക്കരുത്. "PUSHi", "mXPUSHi", "XPUSHi" എന്നിവയും കാണുക.

അസാധുവായ mPUSHi(IV iv)

mPUSHn സ്റ്റാക്കിലേക്ക് ഇരട്ടി അമർത്തുക. സ്റ്റാക്കിൽ ഈ ഘടകത്തിന് ഇടം ഉണ്ടായിരിക്കണം. ചെയ്യുന്നു
"TARG" ഉപയോഗിക്കരുത്. "PUSHn", "mXPUSHn", "XPUSHn" എന്നിവയും കാണുക.

അസാധുവായ mPUSHn(NV nv)

mPUSHp ഒരു സ്ട്രിംഗ് സ്റ്റാക്കിലേക്ക് തള്ളുക. സ്റ്റാക്കിൽ ഈ ഘടകത്തിന് ഇടം ഉണ്ടായിരിക്കണം. ദി
"len" എന്നത് സ്ട്രിംഗിന്റെ നീളം സൂചിപ്പിക്കുന്നു. "TARG" ഉപയോഗിക്കുന്നില്ല. "PUSHp" എന്നതും കാണുക,
"mXPUSHp", "XPUSHp" എന്നിവ.

ശൂന്യമായ mPUSHp(char* str, STRLEN ലെൻ)

mPUSH-കൾ ഒരു SV സ്റ്റാക്കിലേക്ക് തള്ളുകയും SV-യെ മാരകമാക്കുകയും ചെയ്യുന്നു. സ്റ്റാക്കിന് ഇടം ഉണ്ടായിരിക്കണം
ഈ ഘടകം. "TARG" ഉപയോഗിക്കുന്നില്ല. "PUSHs", "mXPUSHs" എന്നിവയും കാണുക.

അസാധുവായ mPUSHs(SV* sv)

mPUSHu ഒപ്പിടാത്ത ഒരു പൂർണ്ണസംഖ്യ സ്റ്റാക്കിലേക്ക് തള്ളുക. സ്റ്റാക്കിൽ ഇതിന് ഇടമുണ്ടായിരിക്കണം
ഘടകം. "TARG" ഉപയോഗിക്കുന്നില്ല. "PUSHu", "mXPUSHu", "XPUSHu" എന്നിവയും കാണുക.

ശൂന്യമായ mPUSHu (UV uv)

mXPUSHi സ്റ്റാക്കിലേക്ക് ഒരു പൂർണ്ണസംഖ്യ അമർത്തുക, ആവശ്യമെങ്കിൽ സ്റ്റാക്ക് നീട്ടുക. ഉപയോഗിക്കുന്നില്ല
"TARG". "XPUSHi", "mPUSHi", "PUSHi" എന്നിവയും കാണുക.

അസാധുവായ mXPUSHi(IV iv)

mXPUSHn സ്റ്റാക്കിലേക്ക് ഇരട്ടി അമർത്തുക, ആവശ്യമെങ്കിൽ സ്റ്റാക്ക് നീട്ടുക. ഉപയോഗിക്കുന്നില്ല
"TARG". "XPUSHn", "mPUSHn", "PUSHn" എന്നിവയും കാണുക.

അസാധുവായ mXPUSHn(NV nv)

mXPUSHp സ്റ്റാക്കിലേക്ക് ഒരു സ്ട്രിംഗ് തള്ളുക, ആവശ്യമെങ്കിൽ സ്റ്റാക്ക് നീട്ടുക. "ലെൻ"
സ്ട്രിംഗിന്റെ നീളം സൂചിപ്പിക്കുന്നു. "TARG" ഉപയോഗിക്കുന്നില്ല. "XPUSHp" എന്നതും കാണുക,
"mPUSHp", "PUSHp" എന്നിവ.

ശൂന്യമായ mXPUSHp(char* str, STRLEN ലെൻ)

mXPUSH-കൾ ഒരു SV സ്റ്റാക്കിലേക്ക് തള്ളുക, ആവശ്യമെങ്കിൽ സ്റ്റാക്ക് നീട്ടുകയും SV-യെ മാരകമാക്കുകയും ചെയ്യുന്നു.
"TARG" ഉപയോഗിക്കുന്നില്ല. "XPUSHs", "mPUSHs" എന്നിവയും കാണുക.

അസാധുവായ mXPUSHs(SV* sv)

mXPUSHu ഒപ്പിടാത്ത ഒരു പൂർണ്ണസംഖ്യ സ്റ്റാക്കിലേക്ക് തള്ളുക, ആവശ്യമെങ്കിൽ സ്റ്റാക്ക് നീട്ടുക. ചെയ്യുന്നു
"TARG" ഉപയോഗിക്കരുത്. "XPUSHu", "mPUSHu", "PUSHu" എന്നിവയും കാണുക.

അസാധുവായ mXPUSHu(UV uv)

ഒറിഗ്മാർക്ക്
XSUB-നുള്ള യഥാർത്ഥ സ്റ്റാക്ക് മാർക്ക്. "dORIGMARK" കാണുക.

POPi സ്റ്റാക്കിൽ നിന്ന് ഒരു പൂർണ്ണസംഖ്യ പോപ്പ് ചെയ്യുന്നു.

IV POPi

POPl സ്റ്റാക്കിൽ നിന്ന് ഒരു നീണ്ട പോപ്പ്.

നീണ്ട POPl

POPn സ്റ്റാക്കിൽ നിന്ന് ഇരട്ടി പോപ്പ് ചെയ്യുന്നു.

NV POPn

POPp സ്റ്റാക്കിൽ നിന്ന് ഒരു സ്ട്രിംഗ് പോപ്പ് ചെയ്യുന്നു.

ചാര്* POPp

POPpbytex
സ്റ്റാക്കിൽ നിന്ന് ഒരു സ്ട്രിംഗ് പോപ്പ് ചെയ്യുന്നു, അതിൽ ബൈറ്റുകൾ അടങ്ങിയിരിക്കണം അതായത് <256 പ്രതീകങ്ങൾ.

char* POPpbytex

POPpx സ്റ്റാക്കിൽ നിന്ന് ഒരു സ്ട്രിംഗ് പോപ്പ് ചെയ്യുന്നു. POPp-ന് സമാനമാണ്. എന്നതിന് രണ്ട് പേരുകളുണ്ട്
ചരിത്രപരമായ കാരണങ്ങൾ.

char* POPpx

POP-കൾ സ്റ്റാക്കിൽ നിന്ന് ഒരു SV പോപ്പ് ചെയ്യുന്നു.

SV* POP-കൾ

പുഷി സ്റ്റാക്കിലേക്ക് ഒരു പൂർണ്ണസംഖ്യ അമർത്തുക. സ്റ്റാക്കിൽ ഈ ഘടകത്തിന് ഇടം ഉണ്ടായിരിക്കണം.
'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു. "TARG" ഉപയോഗിക്കുന്നു, അതിനാൽ "dTARGET" അല്ലെങ്കിൽ "dXSTARG" എന്നതിലേക്ക് വിളിക്കണം
അത് പ്രഖ്യാപിക്കുക. ലിസ്റ്റുകൾ തിരികെ നൽകുന്നതിന് ഒന്നിലധികം "TARG"-ഓറിയന്റഡ് മാക്രോകളെ വിളിക്കരുത്
XSUB-കൾ - പകരം "mPUSHi" കാണുക. "XPUSHi", "mXPUSHi" എന്നിവയും കാണുക.

ശൂന്യമായ പുഷി (IV iv)

പുഷ്മാർക്ക്
ഒരു കോൾബാക്കിൽ ആർഗ്യുമെന്റുകൾക്കായി ബ്രാക്കറ്റ് തുറക്കുന്നു. "പുട്ട്ബാക്ക്" കാണുക, perlcall.

പുഷ്മാർക്ക് (എസ്പി) അസാധുവാണ്

പുഷ്മോർട്ടൽ
ഒരു പുതിയ മോർട്ടൽ SV സ്റ്റാക്കിലേക്ക് തള്ളുക. സ്റ്റാക്കിൽ ഈ ഘടകത്തിന് ഇടം ഉണ്ടായിരിക്കണം.
"TARG" ഉപയോഗിക്കുന്നില്ല. "പുഷ്", "എക്സ്പുഷ്മോർട്ടൽ", "എക്സ്പുഷ്" എന്നിവയും കാണുക.

ശൂന്യമായ പുഷ്മോർട്ടൽ()

PUSHn സ്റ്റാക്കിലേക്ക് ഇരട്ടി തള്ളുക. സ്റ്റാക്കിൽ ഈ ഘടകത്തിന് ഇടം ഉണ്ടായിരിക്കണം. കൈകാര്യം ചെയ്യുന്നു
'സെറ്റ്' മാജിക്. "TARG" ഉപയോഗിക്കുന്നു, അതിനാൽ പ്രഖ്യാപിക്കാൻ "dTARGET" അല്ലെങ്കിൽ "dXSTARG" വിളിക്കണം
അത്. XSUB-ൽ നിന്നുള്ള ലിസ്റ്റുകൾ തിരികെ നൽകാൻ ഒന്നിലധികം "TARG"-ഓറിയന്റഡ് മാക്രോകളെ വിളിക്കരുത് - കാണുക
പകരം "mPUSHn". "XPUSHn", "mXPUSHn" എന്നിവയും കാണുക.

അസാധുവായ PUSHn (NV nv)

PUSHp ഒരു സ്ട്രിംഗ് സ്റ്റാക്കിലേക്ക് തള്ളുക. സ്റ്റാക്കിൽ ഈ ഘടകത്തിന് ഇടം ഉണ്ടായിരിക്കണം. ദി
"len" എന്നത് സ്ട്രിംഗിന്റെ നീളം സൂചിപ്പിക്കുന്നു. 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു. "TARG" ഉപയോഗിക്കുന്നു, അങ്ങനെ
അത് പ്രഖ്യാപിക്കാൻ "dTARGET" അല്ലെങ്കിൽ "dXSTARG" വിളിക്കണം. ഒന്നിലധികം വിളിക്കരുത്
XSUB-ൽ നിന്നുള്ള ലിസ്റ്റുകൾ തിരികെ നൽകുന്നതിന് "TARG"-ഓറിയന്റഡ് മാക്രോകൾ - പകരം "mPUSHp" കാണുക. കാണുക
കൂടാതെ "XPUSHp", "mXPUSHp" എന്നിവയും.

ശൂന്യമായ PUSHp(char* str, STRLEN ലെൻ)

പുഷുകൾ ഒരു എസ്വി സ്റ്റാക്കിലേക്ക് തള്ളുക. സ്റ്റാക്കിൽ ഈ ഘടകത്തിന് ഇടം ഉണ്ടായിരിക്കണം. ഇല്ല
'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുക. "TARG" ഉപയോഗിക്കുന്നില്ല. "PUSHmortal", "XPUSHs" എന്നിവയും കാണുക
"XPUSHmortal".

അസാധുവായ പുഷുകൾ(SV* sv)

പുഷ് ഒപ്പിടാത്ത ഒരു പൂർണ്ണസംഖ്യ സ്റ്റാക്കിലേക്ക് തള്ളുക. സ്റ്റാക്കിൽ ഇതിന് ഇടമുണ്ടായിരിക്കണം
ഘടകം. 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു. "TARG" ഉപയോഗിക്കുന്നു, അതിനാൽ "dTARGET" അല്ലെങ്കിൽ "dXSTARG" ആയിരിക്കണം
അത് പ്രഖ്യാപിക്കാൻ വിളിച്ചു. ലിസ്റ്റുകൾ തിരികെ നൽകാൻ ഒന്നിലധികം "TARG"-ഓറിയന്റഡ് മാക്രോകളെ വിളിക്കരുത്
XSUB-ൽ നിന്ന് - പകരം "mPUSHu" കാണുക. "XPUSHu", "mXPUSHu" എന്നിവയും കാണുക.

ശൂന്യമായ PUSHu (UV uv)

PUTBACK XSUB ആർഗ്യുമെന്റുകൾക്കുള്ള ക്ലോസിംഗ് ബ്രാക്കറ്റ്. ഇത് സാധാരണയായി "xsubpp" ആണ് കൈകാര്യം ചെയ്യുന്നത്. കാണുക
"പുഷ്മാർക്ക്", മറ്റ് ഉപയോഗങ്ങൾക്കായി perlcall.

പുട്ട്ബാക്ക്;

SP സ്റ്റാക്ക് പോയിന്റർ. ഇത് സാധാരണയായി "xsubpp" ആണ് കൈകാര്യം ചെയ്യുന്നത്. "dSP", "SPAGAIN" എന്നിവ കാണുക.

SPAGAIN സ്റ്റാക്ക് പോയിന്റർ വീണ്ടെടുക്കുക. ഒരു കോൾബാക്ക് ശേഷം ഉപയോഗിച്ചു. perlcall കാണുക.

സ്പെയിൻ;

XPUSHi സ്റ്റാക്കിലേക്ക് ഒരു പൂർണ്ണസംഖ്യ അമർത്തുക, ആവശ്യമെങ്കിൽ സ്റ്റാക്ക് നീട്ടുക. 'സെറ്റ്' കൈകാര്യം ചെയ്യുന്നു
ജാലവിദ്യ. "TARG" ഉപയോഗിക്കുന്നു, അതിനാൽ അത് പ്രഖ്യാപിക്കാൻ "dTARGET" അല്ലെങ്കിൽ "dXSTARG" വിളിക്കണം. ചെയ്യുക
XSUB-ൽ നിന്നുള്ള ലിസ്റ്റുകൾ തിരികെ നൽകാൻ ഒന്നിലധികം "TARG"-ഓറിയന്റഡ് മാക്രോകളെ വിളിക്കരുത് - കാണുക
പകരം "mXPUSHi". "PUSHi", "mPUSHi" എന്നിവയും കാണുക.

അസാധുവായ XPUSHi(IV iv)

എക്സ്പുഷ്മോർട്ടൽ
ഒരു പുതിയ മോർട്ടൽ എസ്വി സ്റ്റാക്കിലേക്ക് തള്ളുക, ആവശ്യമെങ്കിൽ സ്റ്റാക്ക് നീട്ടുക. ഇല്ല
"TARG" ഉപയോഗിക്കുക. "XPUSHs", "PUSHmortal", "PUSHs" എന്നിവയും കാണുക.

ശൂന്യമായ XPUSHmortal()

XPUSHn സ്റ്റാക്കിലേക്ക് ഇരട്ടി അമർത്തുക, ആവശ്യമെങ്കിൽ സ്റ്റാക്ക് നീട്ടുക. 'സെറ്റ്' കൈകാര്യം ചെയ്യുന്നു
ജാലവിദ്യ. "TARG" ഉപയോഗിക്കുന്നു, അതിനാൽ അത് പ്രഖ്യാപിക്കാൻ "dTARGET" അല്ലെങ്കിൽ "dXSTARG" വിളിക്കണം. ചെയ്യുക
XSUB-ൽ നിന്നുള്ള ലിസ്റ്റുകൾ തിരികെ നൽകാൻ ഒന്നിലധികം "TARG"-ഓറിയന്റഡ് മാക്രോകളെ വിളിക്കരുത് - കാണുക
പകരം "mXPUSHn". "PUSHn", "mPUSHn" എന്നിവയും കാണുക.

അസാധുവായ XPUSHn(NV nv)

XPUSHp സ്റ്റാക്കിലേക്ക് ഒരു സ്ട്രിംഗ് തള്ളുക, ആവശ്യമെങ്കിൽ സ്റ്റാക്ക് നീട്ടുക. "ലെൻ"
സ്ട്രിംഗിന്റെ നീളം സൂചിപ്പിക്കുന്നു. 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു. "TARG" ഉപയോഗിക്കുന്നു, അങ്ങനെ
അത് പ്രഖ്യാപിക്കാൻ "dTARGET" അല്ലെങ്കിൽ "dXSTARG" വിളിക്കണം. ഒന്നിലധികം വിളിക്കരുത്
XSUB-ൽ നിന്നുള്ള ലിസ്റ്റുകൾ തിരികെ നൽകുന്നതിന് "TARG"-ഓറിയന്റഡ് മാക്രോകൾ - പകരം "mXPUSHp" കാണുക. കാണുക
കൂടാതെ "PUSHp", "mPUSHp" എന്നിവയും.

ശൂന്യമായ XPUSHp(char* str, STRLEN ലെൻ)

XPUSH-കൾ ഒരു SV സ്റ്റാക്കിലേക്ക് തള്ളുക, ആവശ്യമെങ്കിൽ സ്റ്റാക്ക് നീട്ടുക. കൈകാര്യം ചെയ്യുന്നില്ല
'സെറ്റ്' മാജിക്. "TARG" ഉപയോഗിക്കുന്നില്ല. "XPUSHmortal", "PUSHs" എന്നിവയും കാണുക
"പുഷ്മോർട്ടൽ".

അസാധുവായ XPUSHs(SV* sv)

XPUSHu ഒരു ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ സ്റ്റാക്കിലേക്ക് തള്ളുക, ആവശ്യമെങ്കിൽ സ്റ്റാക്ക് നീട്ടുക.
'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു. "TARG" ഉപയോഗിക്കുന്നു, അതിനാൽ "dTARGET" അല്ലെങ്കിൽ "dXSTARG" എന്നതിലേക്ക് വിളിക്കണം
അത് പ്രഖ്യാപിക്കുക. ലിസ്റ്റുകൾ തിരികെ നൽകുന്നതിന് ഒന്നിലധികം "TARG"-ഓറിയന്റഡ് മാക്രോകളെ വിളിക്കരുത്
XSUB-കൾ - പകരം "mXPUSHu" കാണുക. "PUSHu", "mPUSHu" എന്നിവയും കാണുക.

അസാധുവായ XPUSHu(UV uv)

XSRETURN
XSUB-ൽ നിന്ന് മടങ്ങുക, സ്റ്റാക്കിലെ ഇനങ്ങളുടെ എണ്ണം സൂചിപ്പിക്കുന്നു. ഇത് സാധാരണയാണ്
"xsubpp" കൈകാര്യം ചെയ്യുന്നു.

അസാധുവായ XSRETURN(ഇന്റ് നിറ്റങ്ങൾ)

XSRETURN_EMPTY
ഒരു XSUB-ൽ നിന്ന് ശൂന്യമായ ഒരു ലിസ്റ്റ് ഉടനടി തിരികെ നൽകുക.

XSRETURN_EMPTY;

XSRETURN_IV
ഒരു XSUB-ൽ നിന്ന് ഉടനടി ഒരു പൂർണ്ണസംഖ്യ തിരികെ നൽകുക. "XST_mIV" ഉപയോഗിക്കുന്നു.

അസാധുവായ XSRETURN_IV(IV iv)

XSRETURN_NO
ഉടൻ തന്നെ ഒരു XSUB-ൽ നിന്ന് &PL_sv_no തിരികെ നൽകുക. "XST_mNO" ഉപയോഗിക്കുന്നു.

XSRETURN_NO;

XSRETURN_NV
ഒരു XSUB-ൽ നിന്ന് ഉടനടി ഇരട്ടി തിരികെ നൽകുക. "XST_mNV" ഉപയോഗിക്കുന്നു.

അസാധുവായ XSRETURN_NV(NV nv)

XSRETURN_PV
ഒരു XSUB-ൽ നിന്നുള്ള ഒരു സ്‌ട്രിംഗിന്റെ ഒരു പകർപ്പ് ഉടനടി തിരികെ നൽകുക. "XST_mPV" ഉപയോഗിക്കുന്നു.

ശൂന്യമായ XSRETURN_PV(char* str)

XSRETURN_UNDEF
ഉടൻ തന്നെ ഒരു XSUB-ൽ നിന്ന് &PL_sv_undef തിരികെ നൽകുക. "XST_mUNDEF" ഉപയോഗിക്കുന്നു.

XSRETURN_UNDEF;

XSRETURN_UV
ഒരു XSUB-ൽ നിന്ന് ഉടനടി ഒരു പൂർണ്ണസംഖ്യ തിരികെ നൽകുക. "XST_mUV" ഉപയോഗിക്കുന്നു.

അസാധുവായ XSRETURN_UV(IV uv)

XSRETURN_അതെ
ഉടൻ തന്നെ ഒരു XSUB-ൽ നിന്ന് &PL_sv_yes തിരികെ നൽകുക. "XST_mYES" ഉപയോഗിക്കുന്നു.

XSRETURN_അതെ;

XST_mIV സ്റ്റാക്കിലെ "pos" എന്ന നിർദ്ദിഷ്‌ട സ്ഥാനത്ത് ഒരു പൂർണ്ണസംഖ്യ സ്ഥാപിക്കുക. മൂല്യം ആണ്
ഒരു പുതിയ മോർട്ടൽ എസ്‌വിയിൽ സൂക്ഷിച്ചിരിക്കുന്നു.

അസാധുവായ XST_mIV(int pos, IV iv)

XST_mNO സ്റ്റാക്കിലെ "പോസ്" എന്ന നിർദ്ദിഷ്‌ട സ്ഥാനത്തേക്ക് &PL_sv_no സ്ഥാപിക്കുക.

അസാധുവായ XST_mNO(int pos)

XST_mNV സ്റ്റാക്കിലെ "പോസ്" എന്ന നിർദ്ദിഷ്‌ട സ്ഥാനത്തേക്ക് ഇരട്ടി വയ്ക്കുക. മൂല്യം ആണ്
ഒരു പുതിയ മോർട്ടൽ എസ്‌വിയിൽ സൂക്ഷിച്ചിരിക്കുന്നു.

അസാധുവായ XST_mNV(int pos, NV nv)

XST_mPV ഒരു സ്‌ട്രിംഗിന്റെ ഒരു പകർപ്പ് സ്റ്റാക്കിലെ "pos" എന്ന നിർദ്ദിഷ്‌ട സ്ഥാനത്ത് സ്ഥാപിക്കുക. ദി
മൂല്യം ഒരു പുതിയ മോർട്ടൽ എസ്വിയിൽ സംഭരിച്ചിരിക്കുന്നു.

അസാധുവായ XST_mPV(int pos, char* str)

XST_mUNDEF
സ്റ്റാക്കിലെ "പോസ്" എന്ന നിർദ്ദിഷ്‌ട സ്ഥാനത്തേക്ക് &PL_sv_undef സ്ഥാപിക്കുക.

അസാധുവായ XST_mUNDEF(int pos)

XST_mYES
സ്റ്റാക്കിലെ "പോസ്" എന്ന നിർദ്ദിഷ്‌ട സ്ഥാനത്ത് &PL_sv_yes സ്ഥാപിക്കുക.

അസാധുവായ XST_mYES(int pos)

SV ഫ്ലാഗുകൾ

svtype പേൾ തരങ്ങൾക്കുള്ള പതാകകളുടെ ഒരു enum. ഇവ ഫയലിൽ കാണാം sv.h "svtype" ൽ
enum. "SvTYPE" മാക്രോ ഉപയോഗിച്ച് ഈ ഫ്ലാഗുകൾ പരീക്ഷിക്കുക.

തരങ്ങൾ ഇവയാണ്:

SVt_NULL
SVt_IV
SVt_NV
SVt_RV
SVt_PV
SVt_PVIV
SVt_PVNV
SVt_PVMG
SVt_INVLIST
SVt_REGEXP
SVt_PVGV
SVt_PVLV
SVt_PVAV
SVt_PVHV
SVt_PVCV
SVt_PVFM
SVt_PVIO

ഇവ ഏറ്റവും എളുപ്പത്തിൽ താഴെ നിന്ന് മുകളിലേക്ക് വിശദീകരിക്കുന്നു.

SVt_PVIO എന്നത് I/O ഒബ്‌ജക്റ്റുകൾക്കുള്ളതാണ്, SVt_PVFM ഫോർമാറ്റുകൾക്കുള്ളതാണ്, SVt_PVCV സബ്റൂട്ടീനുകൾക്കുള്ളതാണ്,
ഹാഷുകൾക്കായി SVt_PVHV, അറേകൾക്കായി SVt_PVAV.

മറ്റുള്ളവയെല്ലാം സ്കെയിലർ തരങ്ങളാണ്, അതായത്, ഒരു "$" ലേക്ക് ബന്ധിപ്പിക്കാൻ കഴിയുന്ന കാര്യങ്ങൾ
വേരിയബിൾ. ഇവയ്‌ക്ക്, ആന്തരിക തരങ്ങൾ കൂടുതലും ഓർത്തോഗണൽ തരങ്ങളുള്ള തരങ്ങളാണ്
പേൾ ഭാഷ.

അതിനാൽ, "SvTYPE(sv) < SVt_PVAV" പരിശോധിക്കുന്നത് എന്തെങ്കിലുമുണ്ടോ എന്ന് കാണാനുള്ള ഏറ്റവും നല്ല മാർഗമാണ്
ഒരു സ്കെയിലർ ആണ്.

SVt_PVGV ഒരു ടൈപ്പ്ഗ്ലോബിനെ പ്രതിനിധീകരിക്കുന്നു. !SvFAKE(sv) ആണെങ്കിൽ, അത് ഒരു യഥാർത്ഥ, അപ്രസക്തമാണ്
ടൈപ്പ്ഗ്ലോബ്. SvFAKE(sv) ആണെങ്കിൽ, അത് ഒരു ടൈപ്പ്ഗ്ലോബ് ഉള്ള ഒരു സ്കെയിലർ ആണ്
ചുമതലപ്പെടുത്തി. അതിലേക്ക് വീണ്ടും അസൈൻ ചെയ്യുന്നത് ഒരു ടൈപ്പ്ഗ്ലോബ് ആകുന്നത് നിർത്തും. SVt_PVLV
തിരശ്ശീലയ്ക്ക് പിന്നിൽ മറ്റൊരു സ്കെയിലറിലേക്ക് നിയോഗിക്കുന്ന ഒരു സ്കെയിലറിനെ പ്രതിനിധീകരിക്കുന്നു. അത്
ഉപയോഗിച്ചത്, ഉദാ, "substr" എന്നതിന്റെ റിട്ടേൺ മൂല്യത്തിനും ടൈഡ് ഹാഷ്, അറേ ഘടകങ്ങൾക്കും.
ടൈപ്പ്ഗ്ലോബ് ഉൾപ്പെടെ ഏത് സ്കെയിലർ മൂല്യവും ഇതിന് കൈവശം വയ്ക്കാനാകും. SVt_REGEXP പതിവിനുള്ളതാണ്
ഭാവങ്ങൾ. SVt_INVLIST എന്നത് Perl കോർ ആന്തരിക ഉപയോഗത്തിന് മാത്രമുള്ളതാണ്.

SVt_PVMG ഒരു "സാധാരണ" സ്കെയിലറിനെ പ്രതിനിധീകരിക്കുന്നു (ടൈപ്പ്ഗ്ലോബ്, റെഗുലർ എക്സ്പ്രഷൻ അല്ലെങ്കിൽ
പ്രതിനിധി). മിക്ക സ്കെയിലറുകൾക്കും ഒരു പിവിഎംജിയുടെ എല്ലാ ആന്തരിക ഫീൽഡുകളും ആവശ്യമില്ലാത്തതിനാൽ, ഞങ്ങൾ
സാധ്യമാകുമ്പോൾ ചെറിയ സ്ട്രക്‌റ്റുകൾ അനുവദിച്ചുകൊണ്ട് മെമ്മറി സംരക്ഷിക്കുക. മറ്റെല്ലാ തരങ്ങളും
കുറച്ച് ആന്തരിക ഫീൽഡുകളുള്ള SVt_PVMG-യുടെ ലളിതമായ രൂപങ്ങൾ മാത്രം.
SVt_NULL-ന് മാത്രമേ undef ഹോൾഡ് ചെയ്യാൻ കഴിയൂ. SVt_IV-ന് undef, ഒരു പൂർണ്ണസംഖ്യ അല്ലെങ്കിൽ ഒരു റഫറൻസ് കൈവശം വയ്ക്കാൻ കഴിയും.
(SVt_RV എന്നത് SVt_IV എന്നതിന്റെ അപരനാമമാണ്, ഇത് പിന്നാക്ക അനുയോജ്യതയ്ക്ക് വേണ്ടി നിലവിലുണ്ട്.) SVt_NV
അവയിലേതെങ്കിലും അല്ലെങ്കിൽ ഇരട്ടി പിടിക്കാം. SVt_PV ന് undef അല്ലെങ്കിൽ ഒരു സ്ട്രിംഗ് മാത്രമേ പിടിക്കാൻ കഴിയൂ.
SVt_PVI, SVt_PV, SVt_IV എന്നിവയുടെ സൂപ്പർസെറ്റാണ്. SVt_PVNV സമാനമാണ്. SVt_PVMG കഴിയും
SVt_PVNV-ക്ക് കൈവശം വയ്ക്കാൻ കഴിയുന്ന എന്തും പിടിക്കുക, പക്ഷേ അതിന് കഴിയും, പക്ഷേ അനുഗ്രഹിക്കപ്പെടേണ്ടതില്ല അല്ലെങ്കിൽ
മാന്ത്രികമായ.

SVt_INVLIST
സ്കെയിലറുകൾക്കായി ഫ്ലാഗ് ടൈപ്പ് ചെയ്യുക. "svtype" കാണുക.

സ്കെയിലറുകൾക്കായി SVt_IV തരം ഫ്ലാഗ്. "svtype" കാണുക.

SVt_NULL
സ്കെയിലറുകൾക്കായി ഫ്ലാഗ് ടൈപ്പ് ചെയ്യുക. "svtype" കാണുക.

സ്കെയിലറുകൾക്കായി SVt_NV തരം ഫ്ലാഗ്. "svtype" കാണുക.

സ്കെയിലറുകൾക്കായി SVt_PV തരം ഫ്ലാഗ്. "svtype" കാണുക.

SVt_PVAV
അറേകൾക്കായി ഫ്ലാഗ് ടൈപ്പ് ചെയ്യുക. "svtype" കാണുക.

SVt_PVCV
സബ്റൂട്ടീനുകൾക്കായി ഫ്ലാഗ് ടൈപ്പ് ചെയ്യുക. "svtype" കാണുക.

SVt_PVFM
ഫോർമാറ്റുകൾക്കായി ഫ്ലാഗ് ടൈപ്പ് ചെയ്യുക. "svtype" കാണുക.

SVt_PVGV
ടൈപ്പ്ഗ്ലോബുകൾക്ക് ഫ്ലാഗ് ടൈപ്പ് ചെയ്യുക. "svtype" കാണുക.

SVt_PVHV
ഹാഷുകൾക്കായി ഫ്ലാഗ് ടൈപ്പ് ചെയ്യുക. "svtype" കാണുക.

SVt_PVIO
I/O ഒബ്‌ജക്‌റ്റുകൾക്കായി ഫ്ലാഗ് ടൈപ്പ് ചെയ്യുക. "svtype" കാണുക.

SVt_PVIV
സ്കെയിലറുകൾക്കായി ഫ്ലാഗ് ടൈപ്പ് ചെയ്യുക. "svtype" കാണുക.

SVt_PVLV
സ്കെയിലറുകൾക്കായി ഫ്ലാഗ് ടൈപ്പ് ചെയ്യുക. "svtype" കാണുക.

SVt_PVMG
സ്കെയിലറുകൾക്കായി ഫ്ലാഗ് ടൈപ്പ് ചെയ്യുക. "svtype" കാണുക.

SVt_PVNV
സ്കെയിലറുകൾക്കായി ഫ്ലാഗ് ടൈപ്പ് ചെയ്യുക. "svtype" കാണുക.

SVt_REGEXP
പതിവ് എക്സ്പ്രഷനുകൾക്കായി ഫ്ലാഗ് ടൈപ്പ് ചെയ്യുക. "svtype" കാണുക.

SV കൃത്രിമം പ്രവർത്തനങ്ങൾ

boolSV "b" ഒരു യഥാർത്ഥ മൂല്യമാണെങ്കിൽ യഥാർത്ഥ SV അല്ലെങ്കിൽ "b" 0 ആണെങ്കിൽ ഒരു തെറ്റായ SV നൽകുന്നു.

"PL_sv_yes", "PL_sv_no" എന്നിവയും കാണുക.

SV * boolSV(bool b)

croak_xs_usage
xsubs-നുള്ള ഉപയോഗ സന്ദേശം പുറപ്പെടുവിക്കുന്നതിന് "croak()" ന്റെ ഒരു പ്രത്യേക വകഭേദം

croak_xs_usage(cv, "eee_yow");

"cv" ൽ നിന്ന് പാക്കേജിന്റെ പേരും സബ്റൂട്ടീന്റെ പേരും പ്രവർത്തിക്കുന്നു, തുടർന്ന് വിളിക്കുന്നു
"ക്രോക്ക്()". അതിനാൽ "cv" എന്നത് &ouch::awk ആണെങ്കിൽ, അത് "ക്രോക്ക്" എന്ന് വിളിക്കും:

Perl_croak(aTHX_ "ഉപയോഗം: %"SVf"::%"SVf"(%s)", "ouch" "awk",
"eee_yow");

അസാധുവായ croak_xs_usage(const CV *const cv,
കോൺസ്റ്റ് ചാർ *കോൺസ്റ്റ് പാരാംസ്)

get_sv നിർദ്ദിഷ്‌ട പേൾ സ്കെയിലറിന്റെ SV നൽകുന്നു. "ഫ്ലാഗുകൾ" "gv_fetchpv" ലേക്ക് കൈമാറുന്നു.
"GV_ADD" സജ്ജമാക്കുകയും Perl വേരിയബിൾ നിലവിലില്ലെങ്കിൽ അത് സൃഷ്ടിക്കപ്പെടുകയും ചെയ്യും.
"ഫ്ലാഗുകൾ" പൂജ്യമാണെങ്കിൽ വേരിയബിൾ നിലവിലില്ലെങ്കിൽ NULL തിരികെ നൽകും.

ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷന്റെ perl_ ഫോം ഒഴിവാക്കിയിരിക്കുന്നു.

SV* get_sv(const char *name, I32 ഫ്ലാഗുകൾ)

newRV_inc
ഒരു SV-ക്കായി ഒരു RV റാപ്പർ സൃഷ്ടിക്കുന്നു. യഥാർത്ഥ SV-യുടെ റഫറൻസ് എണ്ണം
വർദ്ധിപ്പിച്ചു.

SV* newRV_inc(SV* sv)

പുതിയ എസ്.വി.പദ്നാമം
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

പാഡ് നാമം അടങ്ങിയ ഒരു പുതിയ SV സൃഷ്ടിക്കുന്നു.

SV* newSVpadname(PADNAME *pn)

newSVpvn_utf8
ഒരു പുതിയ SV സൃഷ്ടിക്കുകയും ഒരു സ്ട്രിംഗ് പകർത്തുകയും ചെയ്യുന്നു (അതിൽ "NUL" ("\0") പ്രതീകങ്ങൾ അടങ്ങിയിരിക്കാം)
അതിലേക്ക്. utf8 ശരിയാണെങ്കിൽ, പുതിയ SV-യിൽ "SvUTF8_on" എന്ന് വിളിക്കുന്നു. എ ആയി നടപ്പിലാക്കി
"newSVpvn_flags" ചുറ്റും പൊതിയുക.

SV* newSVpvn_utf8(NULLOK കോൺസ്റ്റ് ചാർ* s, STRLEN ലെൻ,
U32 utf8)

SvCUR SV-യിലുള്ള സ്ട്രിംഗിന്റെ ദൈർഘ്യം നൽകുന്നു. "SvLEN" കാണുക.

STRLEN SvCUR(SV* sv)

SvCUR_set
SV-യിലുള്ള സ്ട്രിംഗിന്റെ നിലവിലെ നീളം സജ്ജമാക്കുക. "SvCUR" കാണുക ഒപ്പം
"SvIV_set".

അസാധുവായ SvCUR_set(SV* sv, STRLEN ലെൻ)

SvEND സ്‌ട്രിംഗിലെ അവസാന പ്രതീകത്തിന് തൊട്ടുപിന്നാലെ സ്‌പോട്ടിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു
SV-യിൽ, സാധാരണയായി "NUL" പ്രതീകം (Perl ആണെങ്കിലും
സ്കെയിലറുകൾക്ക് ഇത് കർശനമായി ആവശ്യമില്ല). "SvCUR" കാണുക. കഥാപാത്രത്തെ ഇതുപോലെ ആക്‌സസ് ചെയ്യുക
*(SvEND(sv)).

മുന്നറിയിപ്പ്: "SvCUR" എന്നത് "SvLEN" എന്നതിന് തുല്യമാണെങ്കിൽ, "SvEND" അൺലോക്കേറ്റ് ചെയ്യാത്തതിലേക്ക് പോയിന്റ് ചെയ്യുന്നു
മെമ്മറി.

char* SvEND(SV* sv)

SvGAMAGIC
എസ്‌വിക്ക് മാന്ത്രികതയോ ഓവർലോഡിംഗോ ലഭിച്ചാൽ ശരിയാണെന്ന് നൽകുന്നു. ഒന്നുകിൽ സത്യമാണെങ്കിൽ
സ്കെയിലർ ഒരു സജീവ ഡാറ്റയാണ്, ഓരോ തവണയും ഒരു പുതിയ മൂല്യം നൽകാനുള്ള കഴിവുണ്ട്
ആക്സസ് ചെയ്യപ്പെടുന്നു. അതിനാൽ ഓരോ ഉപയോക്താവിനും ലോജിക്കൽ ഒരിക്കൽ മാത്രം വായിക്കാൻ നിങ്ങൾ ശ്രദ്ധിക്കണം
തിരികെ നൽകിയ മൂല്യത്തിനൊപ്പം പ്രവർത്തനവും പ്രവർത്തനവും. രണ്ടും ശരിയല്ലെങ്കിൽ സ്കെയിലർ
എന്നെഴുതിയില്ലെങ്കിൽ മൂല്യം മാറില്ല.

U32 SvGAMAGIC(SV* sv)

SvGROW SV-യിലെ ക്യാരക്ടർ ബഫർ വിപുലീകരിക്കുന്നു, അങ്ങനെ അത് സൂചിപ്പിച്ചതിന് ഇടമുണ്ട്
ബൈറ്റുകളുടെ എണ്ണം (ഒരു അധിക ട്രെയിലിംഗ് "NUL" പ്രതീകത്തിനായി സ്ഥലം റിസർവ് ചെയ്യുന്നത് ഓർക്കുക).
ആവശ്യമെങ്കിൽ വിപുലീകരണം നടത്താൻ "sv_grow" വിളിക്കുന്നു. എന്നതിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു
പ്രതീക ബഫർ. SV തരം >= SVt_PV ആയിരിക്കണം. ഒരു ബദൽ വിളിക്കുക എന്നതാണ്
SV-യുടെ തരത്തെക്കുറിച്ച് നിങ്ങൾക്ക് ഉറപ്പില്ലെങ്കിൽ "sv_grow".

char * SvGROW(SV* sv, STRLEN ലെൻ)

SvIOK ഒരു U32 മൂല്യം നൽകുന്നു, SV-യിൽ ഒരു പൂർണ്ണസംഖ്യ ഉണ്ടോ എന്ന് സൂചിപ്പിക്കുന്നു.

U32 SvIOK(SV* sv)

SvIOKp ഒരു U32 മൂല്യം നൽകുന്നു, SV-യിൽ ഒരു പൂർണ്ണസംഖ്യ ഉണ്ടോ എന്ന് സൂചിപ്പിക്കുന്നു. പരിശോധിക്കുന്നു
സ്വകാര്യ ക്രമീകരണം. പകരം "SvIOK" ഉപയോഗിക്കുക.

U32 SvIOKp(SV* sv)

SvIOK_notUV
SV-യിൽ ഒപ്പിട്ട പൂർണ്ണസംഖ്യ ഉണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു.

bool SvIOK_notUV(SV* sv)

SvIOK_off
ഒരു SV-യുടെ IV നില അൺസെറ്റ് ചെയ്യുന്നു.

അസാധുവായ SvIOK_off(SV* sv)

SvIOK_on
ഇത് ഒരു പൂർണ്ണസംഖ്യയാണെന്ന് ഒരു എസ്വിയോട് പറയുന്നു.

അസാധുവാണ് SvIOK_on(SV* sv)

SvIOK_മാത്രം
ഇത് ഒരു പൂർണ്ണസംഖ്യയാണെന്ന് ഒരു SV-യോട് പറയുകയും മറ്റെല്ലാ OK ബിറ്റുകളും പ്രവർത്തനരഹിതമാക്കുകയും ചെയ്യുന്നു.

അസാധുവായ SvIOK_only(SV* sv)

SvIOK_only_UV
ഇത് ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യയാണെന്നും മറ്റെല്ലാ OK ബിറ്റുകളും പ്രവർത്തനരഹിതമാക്കുമെന്നും ഒരു SV-യോട് പറയുന്നു.

അസാധുവായ SvIOK_only_UV(SV* sv)

SvIOK_UV
SV-യിൽ ഉണ്ടായിരിക്കേണ്ട ഒരു പൂർണ്ണസംഖ്യ ഉണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു
ഒപ്പിടാത്തതായി വ്യാഖ്യാനിച്ചു. പരിധിക്കുള്ളിൽ മൂല്യമുള്ള ഒരു നെഗറ്റീവ് അല്ലാത്ത പൂർണ്ണസംഖ്യ
ഒരു IV, UV എന്നിവയിൽ ഒന്നുകിൽ SvUOK അല്ലെങ്കിൽ SVIOK എന്ന് ഫ്ലാഗുചെയ്യാം.

bool SvIOK_UV(SV* sv)

SvIsCOW, SV കോപ്പി-ഓൺ-റൈറ്റ് ആണോ എന്ന് സൂചിപ്പിക്കുന്ന U32 മൂല്യം നൽകുന്നു (ഒന്നുകിൽ പങ്കിട്ട ഹാഷ്
കീ സ്കെയിലറുകൾ, അല്ലെങ്കിൽ 5.9.0 COW-യ്‌ക്കായി കോൺഫിഗർ ചെയ്‌തിട്ടുണ്ടെങ്കിൽ പൂർണ്ണമായ കോപ്പി ഓൺ റൈറ്റ് സ്കെയിലറുകൾ).

U32 SvIsCOW(SV* sv)

SvIsCOW_shared_hash
SV കോപ്പി-ഓൺ-റൈറ്റ് പങ്കിട്ട ഹാഷ് കീ ആണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു
സ്കെയിലർ.

bool SvIsCOW_shared_hash(SV* sv)

SvIV നൽകിയിരിക്കുന്ന എസ്വിയെ ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് നിർബന്ധിക്കുകയും അത് തിരികെ നൽകുകയും ചെയ്യുന്നു. ഒരു പതിപ്പിനായി "SvIVx" കാണുക
sv ഒരിക്കൽ മാത്രം വിലയിരുത്താൻ ഉറപ്പുനൽകുന്നു.

IV SvIV(SV* sv)

SvIVX, പരിശോധനകളോ പരിവർത്തനങ്ങളോ ഇല്ലാതെ, SV-യുടെ IV സ്ലോട്ടിൽ അസംസ്‌കൃത മൂല്യം നൽകുന്നു. മാത്രം
SvIOK ശരിയാണെന്ന് നിങ്ങൾക്ക് ഉറപ്പുണ്ടെങ്കിൽ ഉപയോഗിക്കുക. "SvIV()" എന്നതും കാണുക.

IV SvIVX(SV* sv)

SvIVx തന്നിരിക്കുന്ന SV-യെ ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് നിർബന്ധിക്കുകയും അത് തിരികെ നൽകുകയും ചെയ്യുന്നു. "sv" വിലയിരുത്തുന്നതിനുള്ള ഗ്യാരണ്ടികൾ
ഒരിക്കൽ മാത്രം. "sv" എന്നത് പാർശ്വഫലങ്ങളുള്ള ഒരു പദപ്രയോഗമാണെങ്കിൽ മാത്രം ഇത് ഉപയോഗിക്കുക
കൂടുതൽ കാര്യക്ഷമമായ "SvIV" ഉപയോഗിക്കുക.

IV SvIVx(SV* sv)

SvIV_nomg
"SvIV" പോലെ, എന്നാൽ മാജിക് പ്രോസസ്സ് ചെയ്യുന്നില്ല.

IV SvIV_nomg(SV* sv)

SvIV_set
sv-യിലെ IV പോയിന്ററിന്റെ മൂല്യം val ആയി സജ്ജീകരിക്കുക. അതുതന്നെ നിർവഹിക്കാൻ സാധിക്കും
"SvIVX" എന്നതിലേക്കുള്ള ഒരു lvalue അസൈൻമെന്റോടുകൂടിയ ഈ മാക്രോയുടെ പ്രവർത്തനം. ഭാവി പേൾസിനൊപ്പം,
എന്നിരുന്നാലും, lvalue-ന് പകരം "SvIV_set" ഉപയോഗിക്കുന്നത് കൂടുതൽ കാര്യക്ഷമമായിരിക്കും
"SvIVX" എന്നതിലേക്കുള്ള അസൈൻമെന്റ്.

അസാധുവായ SvIV_set(SV* sv, IV val)

SvLEN ഒരു ഭാഗവും ഉൾപ്പെടുത്താതെ, SV-യിലെ സ്ട്രിംഗ് ബഫറിന്റെ വലുപ്പം നൽകുന്നു
"SvOOK" ആട്രിബ്യൂട്ട്. "SvCUR" കാണുക.

STRLEN SvLEN(SV* sv)

SvLEN_set
SV-യിലുള്ള സ്ട്രിംഗിന്റെ യഥാർത്ഥ നീളം സജ്ജമാക്കുക. "SvIV_set" കാണുക.

അസാധുവായ SvLEN_set(SV* sv, STRLEN ലെൻ)

SvMAGIC_set
sv-യിലെ MAGIC പോയിന്ററിന്റെ മൂല്യം val ആയി സജ്ജീകരിക്കുക. "SvIV_set" കാണുക.

അസാധുവായ SvMAGIC_set(SV* sv, MAGIC* val)

SV-യിൽ ഒരു സംഖ്യയോ പൂർണ്ണസംഖ്യയോ അടങ്ങിയിരിക്കുന്നുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന U32 മൂല്യം SvNIOK നൽകുന്നു
ഇരട്ടി.

U32 SvNIOK(SV* sv)

SvNIOKp ഒരു U32 മൂല്യം നൽകുന്നു, എസ്വിയിൽ ഒരു സംഖ്യയോ പൂർണ്ണസംഖ്യയോ അല്ലെങ്കിൽ
ഇരട്ടി. പരിശോധിക്കുന്നു സ്വകാര്യ ക്രമീകരണം. പകരം "SvNIOK" ഉപയോഗിക്കുക.

U32 SvNIOKp(SV* sv)

SvNIOK_off
ഒരു SV-യുടെ NV/IV നില അൺസെറ്റ് ചെയ്യുന്നു.

അസാധുവായ SvNIOK_off(SV* sv)

SV-യിൽ ഇരട്ടി അടങ്ങിയിട്ടുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന U32 മൂല്യം SvNOK നൽകുന്നു.

U32 SvNOK(SV* sv)

SvNOKp ഒരു U32 മൂല്യം നൽകുന്നു, എസ്വിയിൽ ഇരട്ടി അടങ്ങിയിട്ടുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്നു. പരിശോധിക്കുന്നു
സ്വകാര്യ ക്രമീകരണം. പകരം "SvNOK" ഉപയോഗിക്കുക.

U32 SvNOKp(SV* sv)

SvNOK_off
ഒരു SV-യുടെ NV നില അൺസെറ്റ് ചെയ്യുന്നു.

അസാധുവായ SvNOK_off(SV* sv)

SvNOK_on
ഇത് ഒരു ഇരട്ടയാണെന്ന് ഒരു എസ്.വി.യോട് പറയുന്നു.

അസാധുവായ SvNOK_on(SV* sv)

SvNOK_only
ഒരു എസ്‌വിയോട് ഇത് ഡബിൾ ആണെന്ന് പറയുകയും മറ്റെല്ലാ ഓകെ ബിറ്റുകളും പ്രവർത്തനരഹിതമാക്കുകയും ചെയ്യുന്നു.

അസാധുവായ SvNOK_only(SV* sv)

SvNV തന്നിരിക്കുന്ന എസ്‌വിയെ ഇരട്ടിയാക്കി തിരിച്ചുനൽകുക. ഒരു പതിപ്പിനായി "SvNVx" കാണുക
ഒരിക്കൽ മാത്രം sv വിലയിരുത്താൻ ഉറപ്പ് നൽകുന്നു.

NV SvNV(SV* sv)

SvNVX, പരിശോധനകളോ പരിവർത്തനങ്ങളോ ഇല്ലാതെ, SV-യുടെ NV സ്ലോട്ടിൽ അസംസ്‌കൃത മൂല്യം നൽകുന്നു. മാത്രം
SvNOK ശരിയാണെന്ന് നിങ്ങൾക്ക് ഉറപ്പുണ്ടെങ്കിൽ ഉപയോഗിക്കുക. "SvNV()" എന്നതും കാണുക.

NV SvNVX(SV* sv)

SvNVx നൽകിയിരിക്കുന്ന SV-യെ ഇരട്ടിയാക്കുകയും അത് തിരികെ നൽകുകയും ചെയ്യുന്നു. "sv" മാത്രം വിലയിരുത്തുന്നതിന് ഗ്യാരണ്ടികൾ
ഒരിക്കല്. "sv" എന്നത് പാർശ്വഫലങ്ങളുള്ള ഒരു പദപ്രയോഗമാണെങ്കിൽ മാത്രം ഇത് ഉപയോഗിക്കുക, അല്ലാത്തപക്ഷം ഉപയോഗിക്കുക
കൂടുതൽ കാര്യക്ഷമമായ "SvNV".

NV SvNVx(SV* sv)

SvNV_nomg
"SvNV" പോലെ എന്നാൽ മാജിക് പ്രോസസ്സ് ചെയ്യുന്നില്ല.

NV SvNV_nomg(SV* sv)

SvNV_set
sv-യിലെ NV പോയിന്ററിന്റെ മൂല്യം val-ലേക്ക് സജ്ജമാക്കുക. "SvIV_set" കാണുക.

അസാധുവായ SvNV_set(SV* sv, NV val)

മൂല്യം നിർവചിച്ചിട്ടുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു U32 മൂല്യം SvOK നൽകുന്നു. ഇത് മാത്രം
സ്കെയിലറുകൾക്ക് അർത്ഥവത്തായത്.

U32 SvOK(SV* sv)

സ്ട്രിംഗ് ബഫറിലേക്കുള്ള പോയിന്റർ ഓഫ്‌സെറ്റ് ആണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു U32 SvOOK നൽകുന്നു. ഈ
a യുടെ തുടക്കം മുതലുള്ള പ്രതീകങ്ങൾ നീക്കംചെയ്യുന്നത് വേഗത്തിലാക്കാൻ ആന്തരികമായി ഹാക്ക് ഉപയോഗിക്കുന്നു
എസ്.വി.പി.വി. SvOOK ശരിയാകുമ്പോൾ, അനുവദിച്ച സ്ട്രിംഗ് ബഫറിന്റെ ആരംഭം
യഥാർത്ഥത്തിൽ SvPVX-ന് മുമ്പുള്ള "SvOOK_offset()" ബൈറ്റുകൾ. ഈ ഓഫ്‌സെറ്റ് സംഭരിച്ചിരുന്നത്
SvIVX, എന്നാൽ ഇപ്പോൾ ബഫറിന്റെ സ്പെയർ പാർട്ടിൽ സംഭരിച്ചിരിക്കുന്നു.

U32 SvOOK(SV* sv)

SvOOK_offset
വായിക്കുന്നു ലെൻ SvPVX-ൽ നിന്നുള്ള ഓഫ്‌സെറ്റ് അനുവദിച്ചതിന്റെ യഥാർത്ഥ ആരംഭത്തിലേക്ക് മടങ്ങുക
ബഫർ, കാര്യക്ഷമമായി നീക്കം ചെയ്യാൻ "sv_chop" ഉപയോഗിച്ചിട്ടുണ്ടെങ്കിൽ അത് പൂജ്യമല്ല
ബഫറിന്റെ തുടക്കം മുതലുള്ള പ്രതീകങ്ങൾ. ഒരു മാക്രോ ആയി നടപ്പിലാക്കി, അത് എടുക്കുന്നു
എന്ന വിലാസം ലെൻ, അത് "STRLEN" തരത്തിലായിരിക്കണം. വിലയിരുത്തുന്നു sv ഒന്നിലധികം തവണ.
സജ്ജമാക്കുന്നു ലെൻ "SvOOK(sv)" തെറ്റാണെങ്കിൽ 0 വരെ.

അസാധുവായ SvOOK_offset(NN SV*sv, STRLEN ലെൻ)

SV-യിൽ ഒരു പ്രതീക സ്ട്രിംഗ് അടങ്ങിയിട്ടുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു U32 മൂല്യം SvPOK നൽകുന്നു.

U32 SvPOK(SV* sv)

SvPOKp ഒരു U32 മൂല്യം നൽകുന്നു, SV-യിൽ ഒരു പ്രതീക സ്ട്രിംഗ് അടങ്ങിയിട്ടുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്നു. പരിശോധനകൾ
The സ്വകാര്യ ക്രമീകരണം. പകരം "SvPOK" ഉപയോഗിക്കുക.

U32 SvPOKp(SV* sv)

SvPOK_off
ഒരു SV-യുടെ PV നില അൺസെറ്റ് ചെയ്യുന്നു.

അസാധുവായ SvPOK_off(SV* sv)

SvPOK_on
അതൊരു സ്ട്രിംഗ് ആണെന്ന് ഒരു SV യോട് പറയുന്നു.

അസാധുവായ SvPOK_on(SV* sv)

SvPOK_മാത്രം
ഇത് ഒരു സ്ട്രിംഗ് ആണെന്ന് ഒരു SV യോട് പറയുകയും മറ്റെല്ലാ OK ബിറ്റുകളും പ്രവർത്തനരഹിതമാക്കുകയും ചെയ്യുന്നു. തിരിയുകയും ചെയ്യും
UTF-8 സ്റ്റാറ്റസ് ഓഫ്.

അസാധുവായ SvPOK_only(SV* sv)

SvPOK_only_UTF8
ഇത് ഒരു സ്ട്രിംഗ് ആണെന്ന് ഒരു SV യോട് പറയുകയും മറ്റെല്ലാ OK ബിറ്റുകളും പ്രവർത്തനരഹിതമാക്കുകയും ചെയ്യുന്നു
UTF-8 നില അത് പോലെ തന്നെ.

അസാധുവായ SvPOK_only_UTF8(SV* sv)

SvPV, SV-യിലെ സ്‌ട്രിംഗിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു, അല്ലെങ്കിൽ SV-യുടെ ഒരു സ്‌ട്രിംഫൈഡ് ഫോം
SV-യിൽ ഒരു സ്ട്രിംഗ് അടങ്ങിയിട്ടില്ല. SV സ്ട്രിംഗ് ചെയ്ത പതിപ്പ് കാഷെ ചെയ്തേക്കാം
"SvPOK". മാന്ത്രികത കൈകാര്യം ചെയ്യുന്നു. "len" വേരിയബിൾ ദൈർഘ്യത്തിലേക്ക് സജ്ജമാക്കും
സ്ട്രിംഗ് (ഇതൊരു മാക്രോ ആണ്, അതിനാൽ &len ഉപയോഗിക്കരുത്). ഒരു പതിപ്പിനായി "SvPVx" എന്നതും കാണുക
sv ഒരിക്കൽ മാത്രം വിലയിരുത്താൻ ഉറപ്പുനൽകുന്നു.

"SvPV()" എന്നതിന്റെ റിട്ടേൺ മൂല്യം തുല്യമാണെന്നതിന് യാതൊരു ഉറപ്പുമില്ല എന്നത് ശ്രദ്ധിക്കുക
"SvPVX(sv)", അല്ലെങ്കിൽ ആ "SvPVX(sv)" സാധുവായ ഡാറ്റ ഉൾക്കൊള്ളുന്നു, അല്ലെങ്കിൽ തുടർച്ചയായി കോളുകൾ
"SvPV(sv)" ഓരോ തവണയും ഒരേ പോയിന്റർ മൂല്യം നൽകും. ഇത് വഴിയാണ് കാരണം
ഓവർലോഡിംഗ്, കോപ്പി-ഓൺ-റൈറ്റ് തുടങ്ങിയ കാര്യങ്ങൾ കൈകാര്യം ചെയ്യുന്നു. ഈ സന്ദർഭങ്ങളിൽ, ദി
റിട്ടേൺ മൂല്യം ഒരു താത്കാലിക ബഫറിലേക്കോ സമാനമായതോ ആയേക്കാം. നിങ്ങൾക്ക് തികച്ചും ആവശ്യമെങ്കിൽ
SvPVX ഫീൽഡ് സാധുതയുള്ളതായിരിക്കണം (ഉദാഹരണത്തിന്, നിങ്ങൾ അതിലേക്ക് എഴുതാൻ ഉദ്ദേശിക്കുന്നുവെങ്കിൽ), തുടർന്ന് കാണുക
"SvPV_force".

char* SvPV(SV* sv, STRLEN ലെൻ)

SvPVbyte
"SvPV" പോലെ, എന്നാൽ ആവശ്യമെങ്കിൽ ആദ്യം sv ബൈറ്റ് പ്രാതിനിധ്യത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു.

char* SvPVbyte(SV* sv, STRLEN ലെൻ)

SvPVbytex
"SvPV" പോലെ, എന്നാൽ ആവശ്യമെങ്കിൽ ആദ്യം sv ബൈറ്റ് പ്രാതിനിധ്യത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു.
ഒരിക്കൽ മാത്രം sv മൂല്യനിർണ്ണയം നടത്തുമെന്ന് ഉറപ്പുനൽകുന്നു; അല്ലാത്തപക്ഷം കൂടുതൽ കാര്യക്ഷമമായ "SvPVbyte" ഉപയോഗിക്കുക.

char* SvPVbytex(SV* sv, STRLEN ലെൻ)

SvPVbytex_force
"SvPV_force" പോലെ, എന്നാൽ ആവശ്യമെങ്കിൽ ആദ്യം sv ബൈറ്റ് പ്രാതിനിധ്യത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു.
ഒരിക്കൽ മാത്രം sv മൂല്യനിർണ്ണയം നടത്തുമെന്ന് ഉറപ്പുനൽകുന്നു; കൂടുതൽ കാര്യക്ഷമമായ "SvPVbyte_force" ഉപയോഗിക്കുക
അല്ലെങ്കിൽ.

char* SvPVbytex_force(SV* sv, STRLEN ലെൻ)

SvPVbyte_force
"SvPV_force" പോലെ, എന്നാൽ ആവശ്യമെങ്കിൽ ആദ്യം sv ബൈറ്റ് പ്രാതിനിധ്യത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു.

char* SvPVbyte_force(SV* sv, STRLEN ലെൻ)

SvPVbyte_nolen
"SvPV_nolen" പോലെ, എന്നാൽ ആവശ്യമെങ്കിൽ ആദ്യം sv ബൈറ്റ് പ്രാതിനിധ്യത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു.

char* SvPVbyte_nolen(SV* sv)

SvPVutf8
"SvPV" പോലെ, എന്നാൽ ആവശ്യമെങ്കിൽ ആദ്യം sv utf8 ആയി പരിവർത്തനം ചെയ്യുന്നു.

char* SvPVutf8(SV* sv, STRLEN ലെൻ)

SvPVutf8x
"SvPV" പോലെ, എന്നാൽ ആവശ്യമെങ്കിൽ ആദ്യം sv utf8 ആയി പരിവർത്തനം ചെയ്യുന്നു. വിലയിരുത്താൻ ഗ്യാരണ്ടി
sv ഒരിക്കൽ മാത്രം; അല്ലാത്തപക്ഷം കൂടുതൽ കാര്യക്ഷമമായ "SvPVutf8" ഉപയോഗിക്കുക.

char* SvPVutf8x(SV* sv, STRLEN ലെൻ)

SvPVutf8x_force
"SvPV_force" പോലെ, എന്നാൽ ആവശ്യമെങ്കിൽ ആദ്യം sv utf8 ആയി പരിവർത്തനം ചെയ്യുന്നു. ഗ്യാരണ്ടി നൽകുന്നു
sv ഒരിക്കൽ മാത്രം വിലയിരുത്തുക; അല്ലാത്തപക്ഷം കൂടുതൽ കാര്യക്ഷമമായ "SvPVutf8_force" ഉപയോഗിക്കുക.

char* SvPVutf8x_force(SV* sv, STRLEN ലെൻ)

SvPVutf8_force
"SvPV_force" പോലെ, എന്നാൽ ആവശ്യമെങ്കിൽ ആദ്യം sv utf8 ആയി പരിവർത്തനം ചെയ്യുന്നു.

char* SvPVutf8_force(SV* sv, STRLEN ലെൻ)

SvPVutf8_nolen
"SvPV_nolen" പോലെ, എന്നാൽ ആവശ്യമെങ്കിൽ ആദ്യം sv utf8 ആയി പരിവർത്തനം ചെയ്യുന്നു.

char* SvPVutf8_nolen(SV* sv)

SvPVX, SV-യിലെ ഫിസിക്കൽ സ്‌ട്രിംഗിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു. SV-യിൽ ഒരു സ്ട്രിംഗ് ഉണ്ടായിരിക്കണം.
5.9.3-ന് മുമ്പ്, SV-യുടെ തരം >= അല്ലാതെ ഈ മാക്രോ എക്സിക്യൂട്ട് ചെയ്യുന്നത് സുരക്ഷിതമല്ല.
SVt_PV.

ഒരു XS AUTOLOAD-ൽ ഒരു ഓട്ടോലോഡ് ചെയ്ത സബ്റൂട്ടീന്റെ പേര് സംഭരിക്കുന്നതിനും ഇത് ഉപയോഗിക്കുന്നു
ദിനചര്യ. perlguts-ൽ "XSUBs ഉപയോഗിച്ച് ഓട്ടോലോഡിംഗ്" കാണുക.

char* SvPVX(SV* sv)

SvPVx ഒരു തവണ മാത്രം "sv" മൂല്യനിർണ്ണയം ഉറപ്പുനൽകുന്ന "SvPV" യുടെ ഒരു പതിപ്പ്. ഉണ്ടെങ്കിൽ മാത്രം ഇത് ഉപയോഗിക്കുക
"sv" എന്നത് പാർശ്വഫലങ്ങളുള്ള ഒരു പദപ്രയോഗമാണ്, അല്ലാത്തപക്ഷം കൂടുതൽ കാര്യക്ഷമമായ "SvPV" ഉപയോഗിക്കുക.

char* SvPVx(SV* sv, STRLEN ലെൻ)

SvPV_force
"SvPV" പോലെ, എന്നാൽ SV-യെ ഒരു സ്ട്രിംഗ് ("SvPOK") ഉൾക്കൊള്ളാൻ നിർബന്ധിക്കും, കൂടാതെ ഒരു
സ്ട്രിംഗ് ("SvPOK_only"), ഹുക്ക് അല്ലെങ്കിൽ ക്രോക്ക് വഴി. നിങ്ങൾ പോകുകയാണെങ്കിൽ നിങ്ങൾക്ക് ബലം ആവശ്യമാണ്
"SvPVX" നേരിട്ട് അപ്ഡേറ്റ് ചെയ്യുക. പ്രക്രിയകൾക്ക് മാന്ത്രികത ലഭിക്കുന്നു.

ഒരു പ്ലെയിൻ പിവിയിലേക്ക് അനിയന്ത്രിതമായ സ്കെയിലർ നിർബന്ധിക്കുന്നത് സ്ട്രിപ്പ് ചെയ്യപ്പെടുമെന്ന് ശ്രദ്ധിക്കുക
അതിൽ നിന്നുള്ള ഉപയോഗപ്രദമായ ഡാറ്റ. ഉദാഹരണത്തിന്, SV "SvROK" ആയിരുന്നെങ്കിൽ, റഫറന്റ് ചെയ്യും
അതിന്റെ റഫറൻസ് എണ്ണം കുറയ്‌ക്കുക, എസ്‌വി തന്നെ ഒരു ആയി പരിവർത്തനം ചെയ്‌തേക്കാം
"SvPOK" സ്കെയിലർ ഒരു സ്ട്രിംഗ് ബഫറോടുകൂടിയ "ഇതുപോലുള്ള ഒരു മൂല്യം അടങ്ങിയിരിക്കുന്നുഅറേ(0x1234)".

char* SvPV_force(SV* sv, STRLEN ലെൻ)

SvPV_force_nomg
"SvPV_force" പോലെ, പക്ഷേ മാജിക്ക് പ്രോസസ്സ് ചെയ്യുന്നില്ല.

char* SvPV_force_nomg(SV* sv, STRLEN ലെൻ)

SvPV_nolen
"SvPV" പോലെ, എന്നാൽ ഒരു ദൈർഘ്യ വേരിയബിൾ സജ്ജീകരിക്കുന്നില്ല.

char* SvPV_nolen(SV* sv)

SvPV_nomg
"SvPV" പോലെ, എന്നാൽ മാജിക് പ്രോസസ്സ് ചെയ്യുന്നില്ല.

char* SvPV_nomg(SV* sv, STRLEN ലെൻ)

SvPV_nomg_nolen
"SvPV_nolen" പോലെ എന്നാൽ മാജിക് പ്രോസസ്സ് ചെയ്യുന്നില്ല.

char* SvPV_nomg_nolen(SV* sv)

SvPV_set
നിങ്ങൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നത് ഇതായിരിക്കില്ല, "sv_usepvn_flags" നിങ്ങൾ ആഗ്രഹിച്ചിരിക്കാം
അല്ലെങ്കിൽ "sv_setpvn" അല്ലെങ്കിൽ "sv_setpvs".

"sv" ലെ PV പോയിന്ററിന്റെ മൂല്യം Perl അലോക്കേറ്റ് ചെയ്ത "NUL"-ടെർമിനേറ്റഡ് ആയി സജ്ജീകരിക്കുക
സ്ട്രിംഗ് "val". "SvIV_set" എന്നതും കാണുക.

മുമ്പത്തെ പിവി ബഫർ സ്വതന്ത്രമാക്കാൻ ഓർക്കുക. പരിശോധിക്കേണ്ട നിരവധി കാര്യങ്ങളുണ്ട്. സൂക്ഷിക്കുക
നിലവിലുള്ള പോയിന്റർ കോപ്പി-ഓൺ-റൈറ്റിലോ മറ്റ് കുഴപ്പങ്ങളിലോ ഉൾപ്പെട്ടിരിക്കാം, അതിനാൽ
"SvOOK_off(sv)" ചെയ്‌ത് "sv_force_normal" അല്ലെങ്കിൽ "SvPV_force" ഉപയോഗിക്കുക (അല്ലെങ്കിൽ SvIsCOW പരിശോധിക്കുക
ഫ്ലാഗ്) ആദ്യം ഈ പരിഷ്ക്കരണം സുരക്ഷിതമാണെന്ന് ഉറപ്പാക്കുക. ഒടുവിൽ, അത് ഇല്ലെങ്കിൽ എ
COW, മുമ്പത്തെ PV ബഫർ സ്വതന്ത്രമാക്കാൻ "SvPV_free" എന്ന് വിളിക്കുക.

അസാധുവായ SvPV_set(SV* sv, char* val)

SvREFCNT
വസ്തുവിന്റെ റഫറൻസ് എണ്ണത്തിന്റെ മൂല്യം നൽകുന്നു.

U32 SvREFCNT(SV* sv)

SvREFCNT_ഡിസം
നൽകിയിരിക്കുന്ന SV-യുടെ റഫറൻസ് എണ്ണം കുറയ്ക്കുന്നു. sv NULL ആയിരിക്കാം.

അസാധുവായ SvREFCNT_dec(SV* sv)

SvREFCNT_dec_NN
SvREFCNT_dec പോലെ തന്നെ, എന്നാൽ നിങ്ങൾക്കറിയാമെങ്കിൽ മാത്രമേ ഉപയോഗിക്കാനാകൂ sv NULL അല്ല. ഞങ്ങൾ മുതൽ
NULLness പരിശോധിക്കേണ്ടതില്ല, ഇത് വേഗതയേറിയതും ചെറുതുമാണ്.

അസാധുവായ SvREFCNT_dec_NN(SV* sv)

SvREFCNT_inc
നൽകിയിരിക്കുന്ന SV-യുടെ റഫറൻസ് എണ്ണം വർദ്ധിപ്പിക്കുന്നു, SV തിരികെ നൽകുന്നു.

ഇനിപ്പറയുന്ന എല്ലാ SvREFCNT_inc* മാക്രോകളും SvREFCNT_inc-ന്റെ ഒപ്റ്റിമൈസ് ചെയ്ത പതിപ്പുകളാണ്,
കൂടാതെ SvREFCNT_inc ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാം.

SV* SvREFCNT_inc(SV* sv)

SvREFCNT_inc_NN
SvREFCNT_inc പോലെ തന്നെ, എന്നാൽ നിങ്ങൾക്കറിയാമെങ്കിൽ മാത്രമേ ഉപയോഗിക്കാനാകൂ sv NULL അല്ല. ഞങ്ങൾ മുതൽ
NULLness പരിശോധിക്കേണ്ടതില്ല, ഇത് വേഗതയേറിയതും ചെറുതുമാണ്.

SV* SvREFCNT_inc_NN(SV* sv)

SvREFCNT_inc_simple
SvREFCNT_inc പോലെ തന്നെ, പക്ഷേ പാർശ്വഫലങ്ങളില്ലാത്ത എക്സ്പ്രഷനുകൾക്കൊപ്പം മാത്രമേ ഉപയോഗിക്കാനാകൂ.
ഞങ്ങൾക്ക് ഒരു താൽക്കാലിക മൂല്യം സംഭരിക്കേണ്ടതില്ല എന്നതിനാൽ, ഇത് വേഗതയുള്ളതാണ്.

SV* SvREFCNT_inc_simple(SV* sv)

SvREFCNT_inc_simple_NN
SvREFCNT_inc_simple പോലെ തന്നെ, എന്നാൽ നിങ്ങൾക്കറിയാമെങ്കിൽ മാത്രമേ ഉപയോഗിക്കാനാകൂ sv NULL അല്ല.
ഞങ്ങൾ NULLness പരിശോധിക്കേണ്ടതില്ല എന്നതിനാൽ, അത് വേഗതയേറിയതും ചെറുതുമാണ്.

SV* SvREFCNT_inc_simple_NN(SV* sv)

SvREFCNT_inc_simple_void
SvREFCNT_inc_simple പോലെ തന്നെ, എന്നാൽ നിങ്ങൾക്ക് റിട്ടേൺ ആവശ്യമില്ലെങ്കിൽ മാത്രമേ ഉപയോഗിക്കാനാകൂ
മൂല്യം. മാക്രോയ്ക്ക് അർത്ഥവത്തായ ഒരു മൂല്യം നൽകേണ്ടതില്ല.

അസാധുവായ SvREFCNT_inc_simple_void(SV* sv)

SvREFCNT_inc_simple_void_NN
SvREFCNT_inc പോലെ തന്നെ, എന്നാൽ നിങ്ങൾക്ക് റിട്ടേൺ മൂല്യം ആവശ്യമില്ലെങ്കിൽ മാത്രമേ ഉപയോഗിക്കാനാകൂ, കൂടാതെ
അത് നിനക്ക് അറിയാം sv NULL അല്ല. മാക്രോയ്ക്ക് അർത്ഥവത്തായ ഒന്ന് തിരികെ നൽകേണ്ടതില്ല
മൂല്യം, അല്ലെങ്കിൽ NULLness പരിശോധിക്കുക, അതിനാൽ ഇത് ചെറുതും വേഗതയുള്ളതുമാണ്.

അസാധുവായ SvREFCNT_inc_simple_void_NN(SV* sv)

SvREFCNT_inc_void
SvREFCNT_inc പോലെ തന്നെ, എന്നാൽ നിങ്ങൾക്ക് റിട്ടേൺ മൂല്യം ആവശ്യമില്ലെങ്കിൽ മാത്രമേ ഉപയോഗിക്കാനാകൂ.
മാക്രോയ്ക്ക് അർത്ഥവത്തായ ഒരു മൂല്യം നൽകേണ്ടതില്ല.

അസാധുവായ SvREFCNT_inc_void(SV* sv)

SvREFCNT_inc_void_NN
SvREFCNT_inc പോലെ തന്നെ, എന്നാൽ നിങ്ങൾക്ക് റിട്ടേൺ മൂല്യം ആവശ്യമില്ലെങ്കിൽ മാത്രമേ ഉപയോഗിക്കാനാകൂ, കൂടാതെ
അത് നിനക്ക് അറിയാം sv NULL അല്ല. മാക്രോയ്ക്ക് അർത്ഥവത്തായ ഒന്ന് തിരികെ നൽകേണ്ടതില്ല
മൂല്യം, അല്ലെങ്കിൽ NULLness പരിശോധിക്കുക, അതിനാൽ ഇത് ചെറുതും വേഗതയുള്ളതുമാണ്.

അസാധുവായ SvREFCNT_inc_void_NN(SV* sv)

SV ഒരു RV ആണെങ്കിൽ SvROK പരിശോധിക്കുന്നു.

U32 SvROK(SV* sv)

SvROK_off
ഒരു SV-യുടെ RV നില അൺസെറ്റ് ചെയ്യുന്നു.

അസാധുവായ SvROK_off(SV* sv)

SvROK_on
അത് ഒരു ആർവി ആണെന്ന് ഒരു എസ്വിയോട് പറയുന്നു.

അസാധുവായ SvROK_on(SV* sv)

SV റിട്ടേൺ ചെയ്യാൻ SvRV ഒരു RV ഡീറഫറൻസ് ചെയ്യുന്നു.

SV* SvRV(SV* sv)

SvRV_set
RV പോയിന്ററിന്റെ മൂല്യം sv-ൽ val ആയി സജ്ജീകരിക്കുക. "SvIV_set" കാണുക.

അസാധുവായ SvRV_set(SV* sv, SV* val)

SvSTASH SV-യുടെ സ്റ്റാഷ് നൽകുന്നു.

HV* SvSTASH(SV* sv)

SvSTASH_set
sv-യിലെ STASH പോയിന്ററിന്റെ മൂല്യം val ആയി സജ്ജീകരിക്കുക. "SvIV_set" കാണുക.

അസാധുവായ SvSTASH_set(SV* sv, HV* val)

SvTAINT ടയിന്റിംഗ് പ്രവർത്തനക്ഷമമാക്കിയിട്ടുണ്ടെങ്കിൽ, നിലവിലെ എക്‌സ്‌പ്രഷനിലേക്ക് കുറച്ച് ഇൻപുട്ടുണ്ടെങ്കിൽ ഒരു എസ്‌വിയെ കളങ്കപ്പെടുത്തുന്നു
കളങ്കപ്പെട്ടതാണ്--സാധാരണയായി ഒരു വേരിയബിൾ, പക്ഷേ ലൊക്കേൽ പോലുള്ള പരോക്ഷമായ ഇൻപുട്ടുകളും
ക്രമീകരണങ്ങൾ. "SvTAINT" ഒരു പദപ്രയോഗത്തിന്റെ ഔട്ട്‌പുട്ടുകളിലേക്ക് ആ കളങ്കം പ്രചരിപ്പിക്കുന്നു
അശുഭാപ്തിവിശ്വാസപരമായ രീതിയിൽ; അതായത്, കൃത്യമായി ശ്രദ്ധിക്കാതെ
ഏത് ഇൻപുട്ടുകളാണ് ഔട്ട്പുട്ടുകളെ സ്വാധീനിക്കുന്നത്.

അസാധുവായ SvTAINT(SV* sv)

SvTAINTED
ഒരു എസ്വി കളങ്കപ്പെട്ടിട്ടുണ്ടോ എന്ന് പരിശോധിക്കുന്നു. TRUE ആണെങ്കിൽ, FALSE എന്ന് നൽകുന്നു.

bool SvTAINTED(SV* sv)

SvTAINTED_off
ഒരു SV കളങ്കപ്പെടുത്തുന്നു. ആകുക വളരെ ഈ പതിവ് ശ്രദ്ധിക്കുക, കാരണം ഇത് ചിലതിൽ ഷോർട്ട് സർക്യൂട്ടുകൾ ഉണ്ടാക്കുന്നു
പേളിന്റെ അടിസ്ഥാന സുരക്ഷാ സവിശേഷതകൾ. XS മൊഡ്യൂൾ രചയിതാക്കൾ ഇത് ഉപയോഗിക്കരുത്
അവർ നിരുപാധികമായി എല്ലാ പ്രത്യാഘാതങ്ങളും പൂർണ്ണമായി മനസ്സിലാക്കുന്നില്ലെങ്കിൽ പ്രവർത്തിക്കുക
മൂല്യത്തെ കളങ്കപ്പെടുത്തുന്നു. അൺടൈൻറിംഗ് സ്റ്റാൻഡേർഡ് പേൾ ഫാഷനിൽ ചെയ്യണം
നേരിട്ട് കളങ്കപ്പെടുത്താത്ത വേരിയബിളുകൾക്കുപകരം ശ്രദ്ധാപൂർവം രൂപപ്പെടുത്തിയ ഒരു regexp.

അസാധുവായ SvTAINTED_off(SV* sv)

SvTAINTED_on
ടയിന്റിംഗ് പ്രവർത്തനക്ഷമമാക്കിയാൽ ഒരു എസ്വിയെ കളങ്കപ്പെട്ടതായി അടയാളപ്പെടുത്തുന്നു.

അസാധുവായ SvTAINTED_on(SV* sv)

SvTRUE എസ്വിയെ ശരിയാണോ തെറ്റാണോ എന്ന് പേർൾ വിലയിരുത്തുമോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു.
കാണുക SvOK() ഒരു നിർവചിക്കപ്പെട്ട/നിർവചിക്കാത്ത ടെസ്റ്റിനായി. സ്കെയിലർ ഇല്ലെങ്കിൽ 'ഗെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു
ഇതിനകം SvPOK, SvIOK അല്ലെങ്കിൽ SvNOK (പൊതുജനങ്ങൾ, സ്വകാര്യ പതാകകളല്ല).

bool SvTRUE(SV* sv)

SvTRUE_nomg
എസ്‌വി ശരിയാണോ തെറ്റാണോ എന്ന് പേർൾ വിലയിരുത്തുമോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു.
കാണുക SvOK() ഒരു നിർവചിക്കപ്പെട്ട/നിർവചിക്കാത്ത ടെസ്റ്റിനായി. 'ഗെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നില്ല.

bool SvTRUE_nomg(SV* sv)

SvTYPE SV-യുടെ തരം നൽകുന്നു. "svtype" കാണുക.

svtype SvTYPE(SV* sv)

SVUOK, SV-ൽ ഉണ്ടായിരിക്കേണ്ട ഒരു പൂർണ്ണസംഖ്യ അടങ്ങിയിട്ടുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു
ഒപ്പിടാത്തതായി വ്യാഖ്യാനിച്ചു. പരിധിക്കുള്ളിൽ മൂല്യമുള്ള ഒരു നെഗറ്റീവ് അല്ലാത്ത പൂർണ്ണസംഖ്യ
ഒരു IV, UV എന്നിവയിൽ ഒന്നുകിൽ SvUOK അല്ലെങ്കിൽ SVIOK എന്ന് ഫ്ലാഗുചെയ്യാം.

bool SvUOK(SV* sv)

SvUPGRADE
ഒരു SV കൂടുതൽ സങ്കീർണ്ണമായ രൂപത്തിലേക്ക് അപ്ഗ്രേഡ് ചെയ്യാൻ ഉപയോഗിക്കുന്നു. നിർവഹിക്കുന്നതിന് "sv_upgrade" ഉപയോഗിക്കുന്നു
ആവശ്യമെങ്കിൽ നവീകരിക്കുക. "svtype" കാണുക.

അസാധുവായ SvUPGRADE(SV* sv, svtype തരം)

SvUTF8 ഒരു SV-യുടെ UTF-32 സ്റ്റാറ്റസ് സൂചിപ്പിക്കുന്ന U8 മൂല്യം നൽകുന്നു. കാര്യങ്ങൾ സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ
ശരിയായി, എസ്വിയിൽ യുടിഎഫ്-8 എൻകോഡ് ചെയ്ത ഡാറ്റ ഉണ്ടോ ഇല്ലയോ എന്ന് ഇത് സൂചിപ്പിക്കുന്നു. നിങ്ങൾ
ഇത് ഉപയോഗിക്കണം ശേഷം ഒരു കോൾ SvPV() അല്ലെങ്കിൽ അതിന്റെ വകഭേദങ്ങളിൽ ഒന്ന്, എന്തെങ്കിലും വിളിക്കുകയാണെങ്കിൽ
സ്ട്രിംഗ് ഓവർലോഡിംഗ് ആന്തരിക ഫ്ലാഗ് അപ്ഡേറ്റ് ചെയ്യുന്നു.

നിങ്ങൾക്ക് ബൈറ്റ്സ് പ്രാഗ്മ കണക്കിലെടുക്കണമെങ്കിൽ, പകരം "DO_UTF8" ഉപയോഗിക്കുക.

U32 SvUTF8(SV* sv)

SvUTF8_off
ഒരു SV-യുടെ UTF-8 സ്റ്റാറ്റസ് അൺസെറ്റ് ചെയ്യുന്നു (ഡാറ്റ മാറ്റിയിട്ടില്ല, ഫ്ലാഗ് മാത്രം). അരുത്
നിസ്സാരമായി ഉപയോഗിക്കുക.

അസാധുവായ SvUTF8_off(SV *sv)

SvUTF8_on
ഒരു SV-യുടെ UTF-8 സ്റ്റാറ്റസ് ഓണാക്കുക (ഡാറ്റ മാറ്റിയിട്ടില്ല, ഫ്ലാഗ് മാത്രം). ചെയ്യുക
നിസ്സാരമായി ഉപയോഗിക്കരുത്.

അസാധുവാണ് SvUTF8_on(SV *sv)

SvUV നൽകിയിരിക്കുന്ന SV-യെ ഒപ്പിടാത്ത ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് നിർബന്ധിക്കുകയും അത് തിരികെ നൽകുകയും ചെയ്യുന്നു. a എന്നതിനായി "SvUVx" കാണുക
sv ഒരിക്കൽ മാത്രം വിലയിരുത്താൻ ഉറപ്പുനൽകുന്ന പതിപ്പ്.

UV SvUV(SV* sv)

SvUVX, പരിശോധനകളോ പരിവർത്തനങ്ങളോ ഇല്ലാതെ, SV-യുടെ UV സ്ലോട്ടിൽ അസംസ്‌കൃത മൂല്യം നൽകുന്നു. മാത്രം
SvIOK ശരിയാണെന്ന് നിങ്ങൾക്ക് ഉറപ്പുണ്ടെങ്കിൽ ഉപയോഗിക്കുക. "SvUV()" എന്നതും കാണുക.

UV SvUVX(SV* sv)

SvUVx നൽകിയ SV-യെ ഒപ്പിടാത്ത ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് നിർബന്ധിക്കുകയും അത് തിരികെ നൽകുകയും ചെയ്യുന്നു. ഗ്യാരണ്ടി നൽകുന്നു
"sv" ഒരിക്കൽ മാത്രം വിലയിരുത്തുക. "sv" എന്നത് വശമുള്ള ഒരു പദപ്രയോഗമാണെങ്കിൽ മാത്രം ഇത് ഉപയോഗിക്കുക
ഇഫക്റ്റുകൾ, അല്ലെങ്കിൽ കൂടുതൽ കാര്യക്ഷമമായ "SvUV" ഉപയോഗിക്കുക.

UV SvUVx(SV* sv)

SvUV_nomg
"SvUV" പോലെ, എന്നാൽ മാജിക് പ്രോസസ്സ് ചെയ്യുന്നില്ല.

UV SvUV_nomg(SV* sv)

SvUV_set
sv-യിലെ UV പോയിന്ററിന്റെ മൂല്യം val-ലേക്ക് സജ്ജമാക്കുക. "SvIV_set" കാണുക.

അസാധുവായ SvUV_set(SV* sv, UV val)

SVVOK, SV-യിൽ ഒരു v-സ്ട്രിംഗ് അടങ്ങിയിട്ടുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു.

bool SvVOK(SV* sv)

sv_catpvn_nomg
"sv_catpvn" പോലെ എന്നാൽ മാജിക് പ്രോസസ്സ് ചെയ്യുന്നില്ല.

void sv_catpvn_nomg(SV* sv, const char* ptr,
STRLEN ലെൻ)

sv_catpv_nomg
"sv_catpv" പോലെ എന്നാൽ മാജിക് പ്രോസസ്സ് ചെയ്യുന്നില്ല.

അസാധുവായ sv_catpv_nomg(SV* sv, const char* ptr)

sv_catsv_nomg
"sv_catsv" പോലെ എന്നാൽ മാജിക് പ്രോസസ്സ് ചെയ്യുന്നില്ല.

ശൂന്യമായ sv_catsv_nomg(SV* dsv, SV* ssv)

sv_derived_from
കൃത്യമായി "sv_derived_from_pv" പോലെ, എന്നാൽ ഒരു "ഫ്ലാഗ്സ്" പാരാമീറ്റർ എടുക്കുന്നില്ല.

bool sv_derived_from(SV* sv, const char *const name)

sv_derived_from_pv
കൃത്യമായി "sv_derived_from_pvn" പോലെയാണ്, എന്നാൽ a എന്നതിന് പകരം ഒരു nul-terminated string എടുക്കുന്നു
സ്ട്രിംഗ്/നീളം ജോടി.

bool sv_derived_from_pv(SV* sv,
കോൺസ്റ്റ് ചാർ * കോൺസ്റ്റ് നാമം,
U32 പതാകകൾ)

sv_derived_from_pvn
നിർദിഷ്ട ക്ലാസിൽ നിന്നാണോ എസ്വി ഉരുത്തിരിഞ്ഞത് എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു at
The C ലെവൽ. പേൾ തലത്തിൽ ഡെറിവേഷൻ പരിശോധിക്കാൻ, "isa()" ഒരു സാധാരണ Perl ആയി വിളിക്കുക
രീതി.

നിലവിൽ, "ഫ്ലാഗുകൾ" എന്നതിനുള്ള ഒരേയൊരു പ്രധാന മൂല്യം SVf_UTF8 ആണ്.

bool sv_derived_from_pvn(SV* sv,
കോൺസ്റ്റ് ചാർ * കോൺസ്റ്റ് നാമം,
const STRLEN ലെൻ, U32 ഫ്ലാഗുകൾ)

sv_derived_from_sv
കൃത്യമായി "sv_derived_from_pvn" പോലെ, എന്നാൽ ഒരു SV രൂപത്തിൽ പേര് സ്ട്രിംഗ് എടുക്കുന്നു
ഒരു സ്ട്രിംഗ്/നീളമുള്ള ജോഡിക്ക് പകരം.

bool sv_derived_from_sv(SV* sv, SV *namesv,
U32 പതാകകൾ)

sv_does "sv_does_pv" ഇഷ്‌ടപ്പെടുന്നു, പക്ഷേ "ഫ്ലാഗ്സ്" പാരാമീറ്റർ എടുക്കുന്നില്ല.

bool sv_does(SV* sv, const char *const name)

sv_does_pv
"sv_does_sv" പോലെ, എന്നാൽ ഒരു SV-ക്ക് പകരം ഒരു nul-terminated string എടുക്കുന്നു.

bool sv_does_pv(SV* sv, const char *const name,
U32 പതാകകൾ)

sv_does_pvn
"sv_does_sv" പോലെ, എന്നാൽ ഒരു SV-ക്ക് പകരം ഒരു സ്ട്രിംഗ്/നീളമുള്ള ജോഡി എടുക്കുന്നു.

bool sv_does_pvn(SV* sv, const char *const name,
const STRLEN ലെൻ, U32 ഫ്ലാഗുകൾ)

sv_does_sv
SV ഒരു നിർദ്ദിഷ്‌ട, പേരുള്ള റോൾ നിർവഹിക്കുന്നുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു. ദി
എസ്‌വി ഒരു പേൾ ഒബ്‌ജക്‌റ്റോ പേൾ ക്ലാസിന്റെ പേരോ ആകാം.

bool sv_does_sv(SV* sv, SV* namesv, U32 ഫ്ലാഗുകൾ)

sv_report_used
ഇതുവരെ സ്വതന്ത്രമാക്കിയിട്ടില്ലാത്ത എല്ലാ SV-കളിലെയും ഉള്ളടക്കങ്ങൾ ഉപേക്ഷിക്കുക (ഡീബഗ്ഗിംഗ് സഹായം).

അസാധുവായ sv_report_used()

sv_setsv_nomg
"sv_setsv" പോലെ എന്നാൽ മാജിക് പ്രോസസ്സ് ചെയ്യുന്നില്ല.

ശൂന്യമായ sv_setsv_nomg(SV* dsv, SV* ssv)

sv_utf8_upgrade_nomg
sv_utf8_upgrade പോലെ, എന്നാൽ "sv"-ൽ മാജിക് ചെയ്യുന്നില്ല.

STRLEN sv_utf8_upgrade_nomg(NN SV *sv)

എസ്വി-ബോഡി വിഹിതം

സംഖ്യ_പോലെ
ഒരു SV-യുടെ ഉള്ളടക്കം ഒരു സംഖ്യ പോലെയാണോ (അല്ലെങ്കിൽ ഒരു സംഖ്യയാണോ) എന്ന് പരിശോധിക്കുക. "ഇൻഫ്" ഒപ്പം
"ഇൻഫിനിറ്റി" എന്നത് സംഖ്യകളായി കണക്കാക്കുന്നു (അതിനാൽ ഒരു നോൺ-നമ്പറിക് മുന്നറിയിപ്പ് നൽകില്ല), പോലും
നിങ്ങളാണെങ്കിൽ atof() അവരെ മുറുകെ പിടിക്കുന്നില്ല. ഗെറ്റ്-മാജിക് അവഗണിക്കപ്പെട്ടു.

I32_പോലെ_നമ്പർ(SV *const sv)

newRV_noinc
ഒരു SV-ക്കായി ഒരു RV റാപ്പർ സൃഷ്ടിക്കുന്നു. യഥാർത്ഥ SV-യുടെ റഫറൻസ് എണ്ണം അല്ല
വർദ്ധിപ്പിച്ചു.

SV* newRV_noinc(SV *const tmpRef)

newSV ഒരു പുതിയ SV സൃഷ്ടിക്കുന്നു. പൂജ്യമല്ലാത്ത "len" പരാമീറ്റർ ബൈറ്റുകളുടെ എണ്ണം സൂചിപ്പിക്കുന്നു
എസ്വിക്ക് ഉണ്ടായിരിക്കേണ്ട മുൻകൂട്ടി അനുവദിച്ച സ്ട്രിംഗ് സ്പേസ്. "NUL" എന്നതിന് പിന്നിലുള്ള ഒരു അധിക ബൈറ്റ്
നിക്ഷിപ്തവുമാണ്. (സ്‌ട്രിംഗ് സ്‌പെയ്‌സ് ആണെങ്കിലും SV-യ്‌ക്കായി SvPOK സജ്ജമാക്കിയിട്ടില്ല
അനുവദിച്ചിരിക്കുന്നു.) പുതിയ SV-യുടെ റഫറൻസ് എണ്ണം 1 ആയി സജ്ജീകരിച്ചിരിക്കുന്നു.

ക്സനുമ്ക്സ ൽ, newSV() പഴയതിനെ മാറ്റിസ്ഥാപിക്കുന്നു NEWSV() API, കൂടാതെ ആദ്യ പാരാമീറ്റർ ഡ്രോപ്പ് ചെയ്യുന്നു,
x, വിളിക്കുന്നവരെ സ്വയം തിരിച്ചറിയാൻ അനുവദിക്കുന്ന ഒരു ഡീബഗ് സഹായം. ഈ സഹായം ലഭിച്ചിട്ടുണ്ട്
PERL_MEM_LOG ("PERL_MEM_LOG" എന്നതിലെ പുതിയ ബിൽഡ് ഓപ്‌ഷൻ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിച്ചു
perlhacktips). പിന്തുണയ്ക്കുന്ന XS മൊഡ്യൂളുകളിൽ ഉപയോഗിക്കുന്നതിന് പഴയ API ഇപ്പോഴും ഉണ്ട്
പഴയ perls.

SV* newSV(const STRLEN ലെൻ)

പുതിയ എസ്.വി.ഹെക്
ഹാഷ് കീ ഘടനയിൽ നിന്ന് ഒരു പുതിയ SV സൃഷ്ടിക്കുന്നു. അത് സ്കെയിലറുകൾ സൃഷ്ടിക്കും
സാധ്യമാകുന്നിടത്ത് പങ്കിട്ട സ്ട്രിംഗ് ടേബിളിലേക്ക്. എങ്കിൽ ഒരു പുതിയ (നിർവചിക്കാത്ത) SV നൽകുന്നു
hek NULL ആണ്.

SV* newSVhek(const HEK *const hek)

newSViv ഒരു പുതിയ SV സൃഷ്ടിക്കുകയും അതിലേക്ക് ഒരു പൂർണ്ണസംഖ്യ പകർത്തുകയും ചെയ്യുന്നു. SV-യുടെ റഫറൻസ് എണ്ണം
1 ആയി സജ്ജമാക്കി.

SV* newSViv(const IV i)

newSVnv ഒരു പുതിയ SV സൃഷ്ടിക്കുകയും അതിലേക്ക് ഒരു ഫ്ലോട്ടിംഗ് പോയിന്റ് മൂല്യം പകർത്തുകയും ചെയ്യുന്നു. റഫറൻസ് എണ്ണം
SV 1 ആയി സജ്ജീകരിച്ചിരിക്കുന്നു.

SV* newSVnv(const NV n)

newSVpv ഒരു പുതിയ SV സൃഷ്ടിക്കുകയും ഒരു സ്ട്രിംഗ് പകർത്തുകയും ചെയ്യുന്നു (അതിൽ "NUL" ("\0") പ്രതീകങ്ങൾ അടങ്ങിയിരിക്കാം)
അതിലേക്ക്. SV-യുടെ റഫറൻസ് എണ്ണം 1 ആയി സജ്ജീകരിച്ചിരിക്കുന്നു. "len" പൂജ്യമാണെങ്കിൽ, Perl ചെയ്യും
ഉപയോഗിച്ച് നീളം കണക്കാക്കുക strlen(), (അതായത് നിങ്ങൾ ഈ ഓപ്ഷൻ ഉപയോഗിക്കുകയാണെങ്കിൽ, അത് "s"
"NUL" പ്രതീകങ്ങൾ ഉൾച്ചേർക്കാൻ കഴിയില്ല, കൂടാതെ "NUL" ബൈറ്റും ഉണ്ടായിരിക്കണം).

കാര്യക്ഷമതയ്ക്കായി, പകരം "newSVpvn" ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക.

SV* newSVpv(const char *const s, const STRLEN ലെൻ)

newSVpvf
ഒരു പുതിയ SV സൃഷ്‌ടിക്കുകയും "sprintf" പോലെ ഫോർമാറ്റ് ചെയ്‌ത സ്ട്രിംഗ് ഉപയോഗിച്ച് അത് ആരംഭിക്കുകയും ചെയ്യുന്നു.

SV* newSVpvf(const char *const pat, ...)

newSVpvn
ഒരു പുതിയ SV സൃഷ്‌ടിക്കുകയും അതിലേക്ക് ഒരു സ്ട്രിംഗ് പകർത്തുകയും ചെയ്യുന്നു, അതിൽ "NUL" പ്രതീകങ്ങൾ അടങ്ങിയിരിക്കാം
("\0") മറ്റ് ബൈനറി ഡാറ്റയും. SV-യുടെ റഫറൻസ് എണ്ണം 1 ആയി സജ്ജീകരിച്ചിരിക്കുന്നു. ശ്രദ്ധിക്കുക
"len" പൂജ്യമാണെങ്കിൽ, Perl ഒരു പൂജ്യം നീളം (Perl) സ്ട്രിംഗ് സൃഷ്ടിക്കും. നിങ്ങളാണ്
ഉറവിട ബഫർ കുറഞ്ഞത് "ലെൻ" ബൈറ്റുകളെങ്കിലും ദൈർഘ്യമുള്ളതാണെന്ന് ഉറപ്പാക്കുന്നതിന് ഉത്തരവാദിത്തമുണ്ട്. എങ്കിൽ
"ബഫർ" ആർഗ്യുമെന്റ് NULL ആണ്, പുതിയ SV നിർവചിക്കപ്പെടില്ല.

SV* newSVpvn(const char *const s, const STRLEN ലെൻ)

newSVpvn_flags
ഒരു പുതിയ SV സൃഷ്ടിക്കുകയും ഒരു സ്ട്രിംഗ് പകർത്തുകയും ചെയ്യുന്നു (അതിൽ "NUL" ("\0") പ്രതീകങ്ങൾ അടങ്ങിയിരിക്കാം)
അതിലേക്ക്. SV-യുടെ റഫറൻസ് എണ്ണം 1 ആയി സജ്ജീകരിച്ചിരിക്കുന്നു. "len" പൂജ്യമാണെങ്കിൽ, ശ്രദ്ധിക്കുക.
പേൾ ഒരു സീറോ ലെങ്ത് സ്ട്രിംഗ് സൃഷ്ടിക്കും. അത് ഉറപ്പാക്കാൻ നിങ്ങൾ ബാധ്യസ്ഥനാണ്
സോഴ്സ് സ്ട്രിംഗ് കുറഞ്ഞത് "ലെൻ" ബൈറ്റുകളെങ്കിലും നീളമുള്ളതാണ്. "s" ആർഗ്യുമെന്റ് NULL ആണെങ്കിൽ പുതിയത്
എസ്.വി. നിലവിൽ അംഗീകരിച്ചിട്ടുള്ള ഫ്ലാഗ് ബിറ്റുകൾ "SVf_UTF8" എന്നിവയും
"SVs_TEMP". "SVs_TEMP" സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, ഫലത്തിൽ "sv_2mortal()" എന്ന് വിളിക്കപ്പെടും
മടങ്ങുന്നതിന് മുമ്പ്. "SVf_UTF8" സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, "s" UTF-8-ലും
പുതിയ SV-യിൽ "SVf_UTF8" ഫ്ലാഗ് സജ്ജീകരിക്കും. "newSVpvn_utf8()" എന്നത് ഒരു സൗകര്യമാണ്
ഈ ഫംഗ്‌ഷനുള്ള റാപ്പർ, എന്ന് നിർവചിച്ചിരിക്കുന്നു

#define newSVpvn_utf8(s, len, u)
newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0)

SV* newSVpvn_flags(const char *const s,
കോൺസ്റ്റ് STRLEN ലെൻ,
const U32 പതാകകൾ)

newSVpvn_share
സ്‌ട്രിംഗിലെ പങ്കിട്ട സ്‌ട്രിംഗിലേക്ക് വിരൽ ചൂണ്ടുന്ന SvPVX_const ഉപയോഗിച്ച് ഒരു പുതിയ SV സൃഷ്‌ടിക്കുന്നു
മേശ. പട്ടികയിൽ സ്ട്രിംഗ് നിലവിലില്ലെങ്കിൽ, അത് ആദ്യം സൃഷ്ടിക്കപ്പെടും.
SvIsCOW ഫ്ലാഗ് ഓണാക്കുന്നു (അല്ലെങ്കിൽ 5.16-ലും അതിനുമുമ്പും വായിക്കാൻ മാത്രം, വ്യാജം). എങ്കിൽ
"hash" പരാമീറ്റർ പൂജ്യമല്ല, ആ മൂല്യം ഉപയോഗിക്കുന്നു; അല്ലെങ്കിൽ ഹാഷ് കണക്കാക്കുന്നു.
സ്ട്രിംഗിന്റെ ഹാഷ് പിന്നീട് "SvSHARED_HASH()" ഉപയോഗിച്ച് SV-യിൽ നിന്ന് വീണ്ടെടുക്കാം
മാക്രോ. പങ്കിട്ട ഹാഷ് കീകൾക്കായി സ്ട്രിംഗ് ടേബിൾ ഉപയോഗിക്കുന്നതാണ് ഇവിടെയുള്ള ആശയം
ഈ സ്ട്രിംഗുകൾക്ക് SvPVX_const == HeKEY ഉണ്ടായിരിക്കും കൂടാതെ ഹാഷ് ലുക്ക്അപ്പ് സ്ട്രിംഗ് ഒഴിവാക്കും
താരതമ്യം ചെയ്യുക.

SV* newSVpvn_share(const char* s, I32 len, U32 ഹാഷ്)

newSVpvs
"newSVpvn" പോലെ, എന്നാൽ ഒരു അക്ഷരത്തിന് പകരം "NUL"-ടെർമിനേറ്റഡ് സ്ട്രിംഗ് എടുക്കുന്നു
സ്ട്രിംഗ്/നീളം ജോടി.

SV* newSVpvs(const char*s)

newSVpvs_flags
"newSVpvn_flags" പോലെ, എന്നാൽ ഒരു അക്ഷരത്തിന് പകരം "NUL"-ടെർമിനേറ്റഡ് സ്ട്രിംഗ് എടുക്കുന്നു
സ്ട്രിംഗ്/നീളം ജോടി.

SV* newSVpvs_flags(const char* s, U32 ഫ്ലാഗുകൾ)

newSVpvs_share
"newSVpvn_share" പോലെ, എന്നാൽ ഒരു അക്ഷരത്തിന് പകരം "NUL"-ടെർമിനേറ്റഡ് സ്ട്രിംഗ് എടുക്കുന്നു
സ്ട്രിംഗ്/നീളം ജോടി, ഹാഷ് പാരാമീറ്റർ ഒഴിവാക്കുന്നു.

SV* newSVpvs_share(const char*s)

newSVpv_share
"newSVpvn_share" പോലെ, എന്നാൽ ഒരു "NUL"-ടെർമിനേറ്റഡ് സ്ട്രിംഗ് എടുക്കുന്നു
സ്ട്രിംഗ്/നീളം ജോടി.

SV* newSVpv_share(const char* s, U32 ഹാഷ്)

newSVrv ചൂണ്ടിക്കാണിക്കാൻ നിലവിലുള്ള RV, "rv" എന്നതിനായി ഒരു പുതിയ SV സൃഷ്ടിക്കുന്നു. "rv" ഒരു RV അല്ലെങ്കിൽ
പിന്നീട് അത് ഒന്നായി നവീകരിക്കും. "ക്ലാസ് നെയിം" അസാധുവാണെങ്കിൽ, പുതിയ എസ്.വി
നിർദ്ദിഷ്ട പാക്കേജിൽ അനുഗ്രഹിക്കപ്പെടും. പുതിയ SV തിരികെ നൽകി, അതിന്റെ റഫറൻസ്
എണ്ണം 1 ആണ്. റഫറൻസ് കൗണ്ട് 1 "rv" യുടെ ഉടമസ്ഥതയിലുള്ളതാണ്.

SV* newSVrv(SV *const rv,
കോൺസ്റ്റ് ചാർ *കോൺസ്റ്റ് ക്ലാസിന്റെ പേര്)

newSVsv യഥാർത്ഥ SV-യുടെ കൃത്യമായ തനിപ്പകർപ്പായ ഒരു പുതിയ SV സൃഷ്ടിക്കുന്നു. (ഉപയോഗിക്കുന്നു
"sv_setv".)

SV* newSVsv(SV *const old)

newSVuv ഒരു പുതിയ SV സൃഷ്‌ടിക്കുകയും അതിൽ ഒപ്പിടാത്ത ഒരു പൂർണ്ണസംഖ്യ പകർത്തുകയും ചെയ്യുന്നു. റഫറൻസ് എണ്ണം
SV 1 ആയി സജ്ജീകരിച്ചിരിക്കുന്നു.

SV* newSVuv(const UV u)

newSV_type
വ്യക്തമാക്കിയ തരത്തിലുള്ള ഒരു പുതിയ SV സൃഷ്ടിക്കുന്നു. പുതിയ SV-യുടെ റഫറൻസ് എണ്ണം
1 ആയി സജ്ജമാക്കി.

SV* newSV_type(const svtype തരം)

sv_2bool
ഈ മാക്രോ ഉപയോഗിക്കുന്നത് മാത്രമാണ് sv_true() അല്ലെങ്കിൽ അതിന്റെ മാക്രോ തത്തുല്യം, എങ്കിൽ മാത്രം
പിന്നീടുള്ളവരുടെ വാദം SvPOK, SvIOK, SvNOK എന്നിവയല്ല. ഇത് sv_2bool_flags എന്ന് വിളിക്കുന്നു
SV_GMAGIC പതാക.

bool sv_2bool(SV *const sv)

sv_2bool_flags
ഈ പ്രവർത്തനം മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ sv_true() സുഹൃത്തുക്കളും, രണ്ടാമത്തേത് ആണെങ്കിൽ മാത്രം
വാദം SvPOK, SvIOK, SvNOK എന്നിവയല്ല. ഫ്ലാഗുകളിൽ SV_GMAGIC അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, പിന്നെ
അത് ചെയ്യുന്നു mg_get() ആദ്യം.

bool sv_2bool_flags(SV *sv, I32 ഫ്ലാഗുകൾ)

sv_2cv വിവിധ ഗാംബിറ്റുകൾ ഉപയോഗിച്ച്, ഒരു SV-യിൽ നിന്ന് ഒരു CV നേടാൻ ശ്രമിക്കുക; കൂടാതെ, സാധ്യമെങ്കിൽ ശ്രമിക്കുക
സ്റ്റാഷിലേക്കും അതുമായി ബന്ധപ്പെട്ട ജിവിയിലേക്കും *st, *gvp എന്നിവ സജ്ജമാക്കുക. "lref" എന്നതിലെ പതാകകൾ
gv_fetchsv-ലേക്ക് കടന്നു.

CV* sv_2cv(SV* sv, HV **const st, GV **const gvp,
const I32 lref)

sv_2io വിവിധ ഗാംബിറ്റുകൾ ഉപയോഗിച്ച്, ഒരു എസ്‌വിയിൽ നിന്ന് ഒരു ഐഒ നേടാൻ ശ്രമിക്കുക: ഐഒ സ്ലോട്ട് ജിവി ആണെങ്കിൽ; അഥവാ
ഞങ്ങൾ ഒരു RV ആണെങ്കിൽ ആവർത്തന ഫലം; അല്ലെങ്കിൽ അതിന്റെ പേരിലുള്ള ചിഹ്നത്തിന്റെ IO സ്ലോട്ട്
ഞങ്ങൾ ഒരു സ്ട്രിംഗാണെങ്കിൽ പി.വി.

കടന്നുപോയ sv-യിൽ 'Get' മാജിക് അവഗണിക്കപ്പെട്ടിരിക്കുന്നു, എന്നാൽ sv ആണെങ്കിൽ "SvRV(sv)"-ൽ വിളിക്കപ്പെടും
ഒരു RV ആണ്.

IO* sv_2io(SV *const sv)

sv_2iv_flags
ആവശ്യമായ ഏതെങ്കിലും സ്ട്രിംഗ് പരിവർത്തനം ചെയ്തുകൊണ്ട് ഒരു SV-യുടെ പൂർണ്ണസംഖ്യ മൂല്യം തിരികെ നൽകുക. എങ്കിൽ
പതാകകളിൽ SV_GMAGIC ഉൾപ്പെടുന്നു, ചെയ്യുന്നു mg_get() ആദ്യം. വഴി സാധാരണയായി ഉപയോഗിക്കുന്നു
"SvIV(sv)", "SvIVx(sv)" മാക്രോകൾ.

IV sv_2iv_flags(SV *const sv, const I32 ഫ്ലാഗുകൾ)

sv_2മോർട്ടൽ
നിലവിലുള്ള ഒരു SV യെ മോർട്ടൽ ആയി അടയാളപ്പെടുത്തുന്നു. SV ഒന്നുകിൽ "ഉടൻ" നശിപ്പിക്കപ്പെടും
FREETMPS-ലേക്കുള്ള വ്യക്തമായ കോൾ, അല്ലെങ്കിൽ പ്രസ്താവന പോലുള്ള സ്ഥലങ്ങളിൽ ഒരു പരോക്ഷ കോൾ
അതിരുകൾ. SvTEMP() ഓണാക്കിയിരിക്കുന്നു, അതായത് SV-യുടെ സ്ട്രിംഗ് ബഫർ ആകാം
ഈ SV പകർത്തിയാൽ "മോഷ്ടിച്ചു". "sv_newmortal", "sv_mortalcopy" എന്നിവയും കാണുക.

SV* sv_2mortal(SV *const sv)

sv_2nv_flags
ആവശ്യമായ ഏതെങ്കിലും സ്‌ട്രിംഗ് അല്ലെങ്കിൽ പൂർണ്ണസംഖ്യ പരിവർത്തനം ചെയ്‌ത് ഒരു SV-യുടെ സംഖ്യ മൂല്യം തിരികെ നൽകുക.
ഫ്ലാഗുകളിൽ SV_GMAGIC ഉൾപ്പെടുന്നുവെങ്കിൽ, ഒരു mg_get() ആദ്യം. വഴി സാധാരണയായി ഉപയോഗിക്കുന്നു
"SvNV(sv)", "SvNVx(sv)" മാക്രോകൾ.

NV sv_2nv_flags(SV *const sv, const I32 ഫ്ലാഗുകൾ)

sv_2pvbyte
SV-യുടെ ബൈറ്റ്-എൻകോഡ് ചെയ്ത പ്രാതിനിധ്യത്തിലേക്ക് ഒരു പോയിന്റർ തിരികെ നൽകുക, അതിലേക്ക് *lp സജ്ജമാക്കുക
നീളം. ഒരു പാർശ്വഫലമായി UTF-8-ൽ നിന്ന് SV തരംതാഴ്ത്തപ്പെടാൻ കാരണമായേക്കാം.

സാധാരണയായി "SvPVbyte" മാക്രോ വഴിയാണ് ആക്സസ് ചെയ്യുന്നത്.

char* sv_2pvbyte(SV *sv, STRLEN *const lp)

sv_2pvutf8
എസ്‌വിയുടെ യു‌ടി‌എഫ്-8-എൻ‌കോഡുചെയ്‌ത പ്രാതിനിധ്യത്തിലേക്ക് ഒരു പോയിന്റർ തിരികെ നൽകുകയും *lp അതിലേക്ക് സജ്ജീകരിക്കുകയും ചെയ്യുക
നീളം. ഒരു പാർശ്വഫലമായി UTF-8 ലേക്ക് SV അപ്‌ഗ്രേഡ് ചെയ്യാൻ കാരണമായേക്കാം.

സാധാരണയായി "SvPVutf8" മാക്രോ വഴിയാണ് ആക്സസ് ചെയ്യുന്നത്.

char* sv_2pvutf8(SV *sv, STRLEN *const lp)

sv_2pv_flags
ഒരു എസ്‌വിയുടെ സ്‌ട്രിംഗ് മൂല്യത്തിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു, ഒപ്പം *lp അതിന്റെ നീളത്തിലേക്ക് സജ്ജീകരിക്കുന്നു. എങ്കിൽ
പതാകകളിൽ SV_GMAGIC ഉൾപ്പെടുന്നു, ചെയ്യുന്നു mg_get() ആദ്യം. എങ്കിൽ ഒരു സ്ട്രിംഗിലേക്ക് sv നിർബന്ധിക്കുന്നു
ആവശ്യമായ. "SvPV_flags" മാക്രോ വഴിയാണ് സാധാരണയായി അഭ്യർത്ഥിക്കുന്നത്. "sv_2pv()" കൂടാതെ
"sv_2pv_nomg" സാധാരണയായി ഇവിടെയും അവസാനിക്കും.

char* sv_2pv_flags(SV *const sv, STRLEN *const lp,
const I32 പതാകകൾ)

sv_2uv_flags
ആവശ്യമായ ഏതെങ്കിലും സ്‌ട്രിംഗ് പരിവർത്തനം ചെയ്‌ത് ഒരു SV-യുടെ ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ മൂല്യം തിരികെ നൽകുക.
ഫ്ലാഗുകളിൽ SV_GMAGIC ഉൾപ്പെടുന്നുവെങ്കിൽ, ഒരു mg_get() ആദ്യം. വഴി സാധാരണയായി ഉപയോഗിക്കുന്നു
"SvUV(sv)", "SvUVx(sv)" മാക്രോകൾ.

UV sv_2uv_flags(SV *const sv, const I32 ഫ്ലാഗുകൾ)

sv_backoff
ഏതെങ്കിലും സ്ട്രിംഗ് ഓഫ്സെറ്റ് നീക്കം ചെയ്യുക. നിങ്ങൾ സാധാരണയായി "SvOOK_off" മാക്രോ റാപ്പർ ഉപയോഗിക്കണം
പകരം.

int sv_backoff(SV *const sv)

sv_bless
ഒരു നിർദ്ദിഷ്‌ട പാക്കേജിലേക്ക് ഒരു SV-യെ അനുഗ്രഹിക്കുന്നു. SV ഒരു RV ആയിരിക്കണം. പാക്കേജ് വേണം
അതിന്റെ സ്റ്റാഷ് ഉപയോഗിച്ച് നിയുക്തമാക്കുക ("gv_stashpv()" കാണുക). എസ്.വി.യുടെ റഫറൻസ് എണ്ണം
ബാധിക്കാത്ത.

SV* sv_bless(SV *const sv, HV *const stash)

sv_catpv
"NUL"-ടെർമിനേറ്റഡ് സ്‌ട്രിംഗിനെ സ്ട്രിംഗിന്റെ അറ്റത്ത് സംയോജിപ്പിക്കുന്നു
എസ്.വി. എസ്‌വിക്ക് യു‌ടി‌എഫ്-8 സ്റ്റാറ്റസ് സെറ്റ് ഉണ്ടെങ്കിൽ, അനുബന്ധ ബൈറ്റുകൾ ഇതായിരിക്കണം
സാധുവായ UTF-8. മാജിക് കൈകാര്യം ചെയ്യുന്നു, പക്ഷേ 'സെറ്റ്' മാജിക് അല്ല. "sv_catpv_mg" കാണുക.

അസാധുവായ sv_catpv(SV *const sv, const char* ptr)

sv_catpvf
"sprintf" പോലെയുള്ള അതിന്റെ ആർഗ്യുമെന്റുകൾ പ്രോസസ്സ് ചെയ്യുകയും ഫോർമാറ്റ് ചെയ്ത ഔട്ട്പുട്ട് ഒരു SV-യിൽ കൂട്ടിച്ചേർക്കുകയും ചെയ്യുന്നു.
അനുബന്ധ ഡാറ്റയിൽ "വൈഡ്" പ്രതീകങ്ങൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ (ഉൾപ്പെടെ, എന്നാൽ ഇവയിൽ മാത്രം പരിമിതപ്പെടുത്തിയിട്ടില്ല,
%s ഉപയോഗിച്ച് ഫോർമാറ്റ് ചെയ്‌ത UTF-8 PV ഉള്ള എസ്‌വികൾ, ഒപ്പം %c ഉപയോഗിച്ച് ഫോർമാറ്റ് ചെയ്‌ത അക്ഷരങ്ങൾ>255),
യഥാർത്ഥ SV UTF-8 ലേക്ക് അപ്‌ഗ്രേഡ് ചെയ്തേക്കാം. 'ഗെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു, പക്ഷേ 'സെറ്റ്' അല്ല
ജാലവിദ്യ. "sv_catpvf_mg" കാണുക. യഥാർത്ഥ എസ്വി യുടിഎഫ്-8 ആണെങ്കിൽ, പാറ്റേൺ ആയിരിക്കണം
സാധുവായ UTF-8; യഥാർത്ഥ SV ബൈറ്റുകളാണെങ്കിൽ, പാറ്റേണും ആയിരിക്കണം.

void sv_catpvf(SV *const sv, const char *const pat,
...)

sv_catpvf_mg
"sv_catpvf" പോലെ, എന്നാൽ 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു.

ശൂന്യമായ sv_catpvf_mg(SV *const sv,
കോൺസ്റ്റ് ചാർ *കോൺസ്റ്റ് പാറ്റ്, ...)

sv_catpvn
SV-യിലുള്ള സ്ട്രിംഗിന്റെ അറ്റത്തേക്ക് സ്ട്രിംഗ് കൂട്ടിച്ചേർക്കുന്നു. "ലെൻ"
പകർത്താനുള്ള ബൈറ്റുകളുടെ എണ്ണം സൂചിപ്പിക്കുന്നു. എസ്‌വിക്ക് UTF-8 സ്റ്റാറ്റസ് സെറ്റ് ഉണ്ടെങ്കിൽ, ദി
കൂട്ടിച്ചേർത്ത ബൈറ്റുകൾ സാധുവായ UTF-8 ആയിരിക്കണം. മാജിക് കൈകാര്യം ചെയ്യുന്നു, പക്ഷേ 'സെറ്റ്' മാജിക് അല്ല.
"sv_catpvn_mg" കാണുക.

void sv_catpvn(SV *dsv, const char *sstr, STRLEN ലെൻ)

sv_catpvn_flags
SV-യിലുള്ള സ്ട്രിംഗിന്റെ അറ്റത്തേക്ക് സ്ട്രിംഗ് കൂട്ടിച്ചേർക്കുന്നു. "ലെൻ"
പകർത്താനുള്ള ബൈറ്റുകളുടെ എണ്ണം സൂചിപ്പിക്കുന്നു.

ഡിഫോൾട്ടായി, SV-ക്ക് ഉണ്ടെങ്കിൽ, അനുബന്ധമായ സ്ട്രിംഗ് സാധുവായ UTF-8 ആണെന്ന് അനുമാനിക്കപ്പെടുന്നു.
UTF-8 സ്റ്റാറ്റസ് സെറ്റ്, കൂടാതെ ബൈറ്റുകളുടെ ഒരു സ്ട്രിംഗ്. ഒരാൾക്ക് അനുബന്ധമായി നിർബന്ധിക്കാം
സ്ട്രിംഗ് "SV_CATUTF8" ഫ്ലാഗ് നൽകിക്കൊണ്ട് UTF-8 ആയി വ്യാഖ്യാനിക്കാം, കൂടാതെ ബൈറ്റുകളായി
"SV_CATBYTES" ഫ്ലാഗ് വിതരണം ചെയ്തുകൊണ്ട്; SV അല്ലെങ്കിൽ അനുബന്ധ സ്ട്രിംഗ് ആയിരിക്കും
ആവശ്യമെങ്കിൽ UTF-8 ലേക്ക് അപ്ഗ്രേഡ് ചെയ്തു.

"ഫ്ലാഗുകൾക്ക്" "SV_SMAGIC" ബിറ്റ് സെറ്റ് ഉണ്ടെങ്കിൽ, പിന്നീട് "dsv" ൽ "mg_set" ചെയ്യും
ഉചിതമായ. "sv_catpvn", "sv_catpvn_nomg" എന്നിവ ഇതിന്റെ അടിസ്ഥാനത്തിൽ നടപ്പിലാക്കുന്നു
പ്രവർത്തനം.

അസാധുവായ sv_catpvn_flags(SV *const dstr,
const char *sstr,
കോൺസ്റ്റ് STRLEN ലെൻ,
const I32 പതാകകൾ)

sv_catpvs
"sv_catpvn" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/നീളമുള്ള ജോഡിക്ക് പകരം ഒരു ലിറ്ററൽ സ്ട്രിംഗ് എടുക്കുന്നു.

അസാധുവായ sv_catpvs(SV* sv, const char* s)

sv_catpvs_flags
"sv_catpvn_flags" പോലെ, എന്നാൽ ഒരു അക്ഷരത്തിന് പകരം "NUL"-ടെർമിനേറ്റഡ് സ്ട്രിംഗ് എടുക്കുന്നു
സ്ട്രിംഗ്/നീളം ജോടി.

അസാധുവായ sv_catpvs_flags(SV* sv, const char* s,
I32 പതാകകൾ)

sv_catpvs_mg
"sv_catpvn_mg" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/നീളമുള്ള ജോഡിക്ക് പകരം ഒരു ലിറ്ററൽ സ്ട്രിംഗ് എടുക്കുന്നു.

അസാധുവായ sv_catpvs_mg(SV* sv, const char* s)

sv_catpvs_nomg
"sv_catpvn_nomg" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/നീളമുള്ള ജോഡിക്ക് പകരം ഒരു ലിറ്ററൽ സ്ട്രിംഗ് എടുക്കുന്നു.

void sv_catpvs_nomg(SV* sv, const char* s)

sv_catpv_flags
"NUL"-ടെർമിനേറ്റഡ് സ്‌ട്രിംഗിനെ സ്ട്രിംഗിന്റെ അറ്റത്ത് സംയോജിപ്പിക്കുന്നു
എസ്.വി. എസ്‌വിക്ക് യു‌ടി‌എഫ്-8 സ്റ്റാറ്റസ് സെറ്റ് ഉണ്ടെങ്കിൽ, അനുബന്ധ ബൈറ്റുകൾ ഇതായിരിക്കണം
സാധുവായ UTF-8. "ഫ്ലാഗുകൾക്ക്" "SV_SMAGIC" ബിറ്റ് സെറ്റ് ഉണ്ടെങ്കിൽ, "mg_set"
അനുയോജ്യമെങ്കിൽ പരിഷ്കരിച്ച എസ്.വി.

അസാധുവായ sv_catpv_flags(SV *dstr, const char *sstr,
const I32 പതാകകൾ)

sv_catpv_mg
"sv_catpv" പോലെ, മാത്രമല്ല 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു.

void sv_catpv_mg(SV *const sv, const char *const ptr)

sv_catsv
SV "ssv" എന്നതിൽ നിന്ന് SV "dsv" എന്നതിലെ സ്ട്രിംഗിന്റെ അവസാനം വരെ സ്ട്രിംഗ് കൂട്ടിച്ചേർക്കുന്നു. എങ്കിൽ
"ssv" ശൂന്യമാണ്, ഒന്നും ചെയ്യുന്നില്ല; അല്ലെങ്കിൽ "dsv" മാത്രം പരിഷ്കരിക്കുന്നു. മാന്ത്രികത കൈകാര്യം ചെയ്യുന്നു
രണ്ട് എസ്‌വികളിലും, പക്ഷേ 'സെറ്റ്' മാജിക് ഇല്ല. "sv_catsv_mg", "sv_catsv_nomg" എന്നിവ കാണുക.

അസാധുവായ sv_catsv(SV *dstr, SV *sstr)

sv_catsv_flags
SV "ssv" എന്നതിൽ നിന്ന് SV "dsv" എന്നതിലെ സ്ട്രിംഗിന്റെ അവസാനം വരെ സ്ട്രിംഗ് കൂട്ടിച്ചേർക്കുന്നു. എങ്കിൽ
"ssv" ശൂന്യമാണ്, ഒന്നും ചെയ്യുന്നില്ല; അല്ലെങ്കിൽ "dsv" മാത്രം പരിഷ്കരിക്കുന്നു. "പതാകകൾ" ഉൾപ്പെടുന്നുവെങ്കിൽ
"SV_GMAGIC" ബിറ്റ് സെറ്റ്, ഉചിതമെങ്കിൽ രണ്ട് SV-കളിലും "mg_get" എന്ന് വിളിക്കും. "പതാകകൾ" ആണെങ്കിൽ
"SV_SMAGIC" ഉൾപ്പെടുത്തുക, "mg_set" പിന്നീട് പരിഷ്കരിച്ച SV-യിൽ വിളിക്കപ്പെടും, എങ്കിൽ
ഉചിതമായ. "sv_catsv", "sv_catsv_nomg", "sv_catsv_mg" എന്നിവ നടപ്പിലാക്കുന്നത്
ഈ പ്രവർത്തനത്തിന്റെ നിബന്ധനകൾ.

അസാധുവായ sv_catsv_flags(SV *const dsv, SV *const ssv,
const I32 പതാകകൾ)

sv_chop സ്ട്രിംഗ് ബഫറിന്റെ ആരംഭത്തിൽ നിന്നുള്ള പ്രതീകങ്ങളുടെ കാര്യക്ഷമമായ നീക്കം.
SvPOK(sv), അല്ലെങ്കിൽ കുറഞ്ഞത് SvPOKp(sv), ശരിയും "ptr" ഒരു പോയിന്ററും ആയിരിക്കണം
സ്ട്രിംഗ് ബഫറിനുള്ളിൽ എവിടെയോ. "ptr" എന്നതിന്റെ ആദ്യ പ്രതീകമായി മാറുന്നു
ക്രമീകരിച്ച സ്ട്രിംഗ്. "OOK ഹാക്ക്" ഉപയോഗിക്കുന്നു. തിരികെ വരുമ്പോൾ, SvPOK(sv), SvPOKp(sv) എന്നിവ മാത്രം
ശരി പതാകകൾക്കിടയിൽ സത്യമായിരിക്കും.

സൂക്ഷിക്കുക: ഈ ഫംഗ്‌ഷൻ മടങ്ങിയ ശേഷം, "ptr", SvPVX_const(sv) എന്നിവ ഇനി പരാമർശിച്ചേക്കില്ല
ഡാറ്റയുടെ അതേ ഭാഗത്തേക്ക്.

ഈ ഫംഗ്‌ഷന്റെ പേരിന്റെ നിർഭാഗ്യകരമായ സാമ്യം പേളിന്റെ "ചോപ്പ്" എന്നതിനോട്
ഓപ്പറേറ്റർ തികച്ചും യാദൃശ്ചികമാണ്. ഈ പ്രവർത്തനം ഇടതുവശത്ത് നിന്ന് പ്രവർത്തിക്കുന്നു; "വെട്ടുക"
വലതുവശത്ത് നിന്ന് പ്രവർത്തിക്കുന്നു.

void sv_chop(SV *const sv, const char *const ptr)

sv_clear
ഒരു എസ്‌വി മായ്‌ക്കുക: ഏതെങ്കിലും ഡിസ്ട്രക്‌റ്ററുകളെ വിളിക്കുക, ബോഡി ഉപയോഗിക്കുന്ന ഏത് മെമ്മറിയും സ്വതന്ത്രമാക്കുക, സൗജന്യമാക്കുക
ശരീരം തന്നെ. എസ് വിയുടെ തലയാണ് അല്ല സ്വതന്ത്രമായി, അതിന്റെ തരം എല്ലാ 1 കളിലും സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിലും
ആഗോള നാശത്തിന്റെ സമയത്ത് അത് അശ്രദ്ധമായി തത്സമയമാണെന്ന് കരുതപ്പെടില്ല
മുതലായവ. REFCNT പൂജ്യമാകുമ്പോൾ മാത്രമേ ഈ ഫംഗ്‌ഷനെ വിളിക്കാവൂ. മിക്കപ്പോഴും
പകരം "sv_free()" (അല്ലെങ്കിൽ അതിന്റെ മാക്രോ റാപ്പർ "SvREFCNT_dec") എന്ന് വിളിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു.

ശൂന്യമായ sv_clear(SV *const orig_sv)

sv_cmp രണ്ട് SV-കളിലെ സ്ട്രിംഗുകളെ താരതമ്യം ചെയ്യുന്നു. എന്ന് സൂചിപ്പിക്കുന്നത് -1, 0, അല്ലെങ്കിൽ 1
"sv1" ലെ സ്ട്രിംഗ് "sv2" ലെ സ്ട്രിംഗിനെക്കാൾ കുറവോ തുല്യമോ വലുതോ ആണ്. ആണ്
UTF-8 ഉം 'ഉപയോഗ ബൈറ്റുകളും' ബോധവാന്മാരാണ്, ഹാൻഡിലുകൾക്ക് മാന്ത്രികത ലഭിക്കുന്നു, ഒപ്പം അതിന്റെ വാദങ്ങളെ നിർബന്ധിക്കുകയും ചെയ്യും
ആവശ്യമെങ്കിൽ ചരടുകൾ. "sv_cmp_locale" എന്നതും കാണുക.

I32 sv_cmp(SV *const sv1, SV *const sv2)

sv_cmp_flags
രണ്ട് SV-കളിലെ സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യുന്നു. എന്ന് സൂചിപ്പിക്കുന്നത് -1, 0, അല്ലെങ്കിൽ 1
"sv1" ലെ സ്ട്രിംഗ് "sv2" ലെ സ്ട്രിംഗിനെക്കാൾ കുറവോ തുല്യമോ വലുതോ ആണ്. ആണ്
UTF-8 ഉം 'ഉപയോഗ ബൈറ്റുകളും' അറിഞ്ഞിരിക്കുകയും ആവശ്യമെങ്കിൽ അതിന്റെ ആർഗ്സ് സ്ട്രിംഗുകളിലേക്ക് നിർബന്ധിക്കുകയും ചെയ്യും. എങ്കിൽ
പതാകകളിൽ SV_GMAGIC ഉൾപ്പെടുന്നു, അത് മാജിക് കൈകാര്യം ചെയ്യുന്നു. ഇതും കാണുക
"sv_cmp_locale_flags".

I32 sv_cmp_flags(SV *const sv1, SV *const sv2,
const U32 പതാകകൾ)

sv_cmp_locale
രണ്ട് SV-കളിലെ സ്ട്രിംഗുകൾ ഒരു ലോക്കൽ-അവേർ രീതിയിൽ താരതമ്യം ചെയ്യുന്നു. UTF-8 ഉം 'ഉപയോഗവുമാണ്
ബൈറ്റുകൾക്ക് അറിയാം, ഹാൻഡിലുകൾക്ക് മാന്ത്രികത ലഭിക്കുന്നു, ആവശ്യമെങ്കിൽ അതിന്റെ ആർഗ്സ് സ്ട്രിംഗുകളിലേക്ക് നിർബന്ധിക്കുകയും ചെയ്യും.
"sv_cmp" എന്നതും കാണുക.

I32 sv_cmp_locale(SV *const sv1, SV *const sv2)

sv_cmp_locale_flags
രണ്ട് SV-കളിലെ സ്ട്രിംഗുകൾ ഒരു ലോക്കൽ-അവേർ രീതിയിൽ താരതമ്യം ചെയ്യുന്നു. UTF-8 ഉം 'ഉപയോഗവുമാണ്
ബൈറ്റുകൾക്ക് അറിയാം, ആവശ്യമെങ്കിൽ അതിന്റെ ആർഗ്സ് സ്ട്രിംഗുകളിലേക്ക് നിർബന്ധിക്കുകയും ചെയ്യും. കൊടികൾ എങ്കിൽ
SV_GMAGIC അടങ്ങിയിരിക്കുന്നു, ഇത് മാന്ത്രികതയെ കൈകാര്യം ചെയ്യുന്നു. "sv_cmp_flags" എന്നതും കാണുക.

I32 sv_cmp_locale_flags(SV *const sv1,
SV * കോൺസ്റ്റ് sv2,
const U32 പതാകകൾ)

sv_collxfrm
ഇത് SV_GMAGIC ഫ്ലാഗ് ഉപയോഗിച്ച് "sv_collxfrm_flags" എന്ന് വിളിക്കുന്നു. "sv_collxfrm_flags" കാണുക.

char* sv_collxfrm(SV *const sv, STRLEN *const nxp)

sv_collxfrm_flags
ഒരു എസ്‌വിക്ക് ഇതിനകം അത് ഇല്ലെങ്കിൽ കോലേറ്റ് ട്രാൻസ്‌ഫോം മാജിക് ചേർക്കുക. കൊടികൾ എങ്കിൽ
SV_GMAGIC അടങ്ങിയിരിക്കുന്നു, അത് ഗെറ്റ്-മാജിക് കൈകാര്യം ചെയ്യുന്നു.

ഏത് സ്കെയിലർ വേരിയബിളും സ്കെയിലർ അടങ്ങുന്ന PERL_MAGIC_collxfrm മാജിക് വഹിക്കാം
വേരിയബിളിന്റെ ഡാറ്റ, എന്നാൽ സാധാരണ മെമ്മറിയുള്ള അത്തരം ഒരു ഫോർമാറ്റിലേക്ക് രൂപാന്തരപ്പെടുന്നു
പ്രാദേശിക ക്രമീകരണങ്ങൾ അനുസരിച്ച് ഡാറ്റ താരതമ്യം ചെയ്യാൻ താരതമ്യം ഉപയോഗിക്കാം.

char* sv_collxfrm_flags(SV *const sv,
STRLEN *const nxp,
I32 കോൺസ്റ്റ് ഫ്ലാഗുകൾ)

sv_copypv_flags
sv_copypv, sv_copypv_nomg എന്നിവയുടെ നടപ്പാക്കൽ. കോളുകൾക്ക് മാജിക് ഇഫ് ഫ്ലാഗുകൾ ഉൾപ്പെടുന്നു
SV_GMAGIC.

അസാധുവായ sv_copypv_flags(SV *const dsv, SV *const ssv,
const I32 പതാകകൾ)

sv_copypv_nomg
sv_copypv പോലെ, പക്ഷേ ആദ്യം മാജിക് നേടുക എന്നല്ല.

void sv_copypv_nomg(SV *const dsv, SV *const ssv)

sv_dec SV-യിലെ മൂല്യം സ്വയമേവ കുറയ്‌ക്കുന്നു, എങ്കിൽ സംഖ്യാ പരിവർത്തനത്തിലേക്ക് സ്ട്രിംഗ് ചെയ്യുന്നു
ആവശ്യമായ. 'ഗെറ്റ്' മാജിക്കും ഓപ്പറേറ്റർ ഓവർലോഡിംഗും കൈകാര്യം ചെയ്യുന്നു.

അസാധുവായ sv_dec(SV *const sv)

sv_dec_nomg
SV-യിലെ മൂല്യം സ്വയമേവ കുറയ്‌ക്കുന്നു, എങ്കിൽ സംഖ്യാ പരിവർത്തനത്തിലേക്ക് സ്ട്രിംഗ് ചെയ്യുന്നു
ആവശ്യമായ. ഓപ്പറേറ്റർ ഓവർലോഡിംഗ് കൈകാര്യം ചെയ്യുന്നു. 'ഗെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നത് ഒഴിവാക്കുന്നു.

അസാധുവായ sv_dec_nomg(SV *const sv)

sv_eq രണ്ട് SVകളിലെയും സ്ട്രിംഗുകൾ സമാനമാണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു. ആണ്
UTF-8 ഉം 'ഉപയോഗ ബൈറ്റുകളും' ബോധവാന്മാരാണ്, ഹാൻഡിലുകൾക്ക് മാന്ത്രികത ലഭിക്കുന്നു, ഒപ്പം അതിന്റെ വാദങ്ങളെ നിർബന്ധിക്കുകയും ചെയ്യും
ആവശ്യമെങ്കിൽ ചരടുകൾ.

I32 sv_eq(SV* sv1, SV* sv2)

sv_eq_flags
രണ്ട് SV-കളിലെ സ്ട്രിംഗുകൾ സമാനമാണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ നൽകുന്നു. ആണ്
UTF-8 ഉം 'ഉപയോഗ ബൈറ്റുകളും' ബോധവൽക്കരിക്കുകയും ആവശ്യമെങ്കിൽ അതിന്റെ ആർഗ്സ് സ്ട്രിംഗുകളിലേക്ക് നിർബന്ധിക്കുകയും ചെയ്യുന്നു. എങ്കിൽ
ഫ്ലാഗുകളിൽ SV_GMAGIC ഉൾപ്പെടുന്നു, അത് ഗെറ്റ്-മാജിക്കും കൈകാര്യം ചെയ്യുന്നു.

I32 sv_eq_flags(SV* sv1, SV* sv2, const U32 ഫ്ലാഗുകൾ)

sv_force_normal_flags
ഒരു SV-യിൽ വിവിധ തരത്തിലുള്ള വ്യാജങ്ങൾ പഴയപടിയാക്കുക, ഇവിടെ വ്യാജമെന്നത് ഒരു സ്ട്രിംഗിനെക്കാൾ "കൂടുതൽ" എന്നാണ് അർത്ഥമാക്കുന്നത്: എങ്കിൽ
പിവി ഒരു പങ്കിട്ട സ്ട്രിംഗാണ്, ഒരു സ്വകാര്യ പകർപ്പ് ഉണ്ടാക്കുക; ഞങ്ങൾ ഒരു റഫർ ആണെങ്കിൽ, റഫിംഗ് നിർത്തുക; എങ്കിൽ
ഞങ്ങൾ ഒരു ഗ്ലോബ് ആണ്, ഒരു xpvmg ലേക്ക് തരംതാഴ്ത്തുക; ഞങ്ങൾ ഒരു കോപ്പി-ഓൺ-റൈറ്റ് സ്കെയിലർ ആണെങ്കിൽ, ഇതാണ്
ഞങ്ങൾ പകർപ്പ് ചെയ്യുമ്പോൾ എഴുതുന്ന സമയം, കൂടാതെ പ്രാദേശികമായും ഉപയോഗിക്കുന്നു; ഇതൊരു vstring ആണെങ്കിൽ,
vstring മാജിക് ഉപേക്ഷിക്കുക. "SV_COW_DROP_PV" സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ കോപ്പി-ഓൺ-റൈറ്റ് സ്കെയിലർ
അതിന്റെ പിവി ബഫർ (എന്തെങ്കിലും ഉണ്ടെങ്കിൽ) ഉപേക്ഷിച്ച് ഒരു പകർപ്പ് ഉണ്ടാക്കുന്നതിനുപകരം SvPOK_off ആയി മാറുന്നു.
(ഈ സ്കെയിലർ മറ്റേതെങ്കിലും മൂല്യത്തിലേക്ക് സജ്ജമാക്കാൻ പോകുന്നിടത്ത് ഉപയോഗിക്കുന്നു.) കൂടാതെ, ദി
അൺറഫ് ചെയ്യുമ്പോൾ "ഫ്ലാഗ്സ്" പാരാമീറ്റർ "sv_unref_flags()" എന്നതിലേക്ക് കടന്നുപോകുന്നു.
"sv_force_normal" ഈ ഫംഗ്‌ഷനെ 0 ആയി സജ്ജീകരിച്ചിരിക്കുന്ന ഫ്ലാഗുകൾ ഉപയോഗിച്ച് വിളിക്കുന്നു.

ഈ SV ആയിരിക്കാൻ പോകുന്നുവെന്ന് പേളിന് സൂചന നൽകാൻ ഈ ഫംഗ്ഷൻ ഉപയോഗിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നു
എഴുതിയത്, കൂടാതെ ഏതെങ്കിലും അധിക പുസ്തക പരിപാലനം ശ്രദ്ധിക്കേണ്ടതുണ്ട്. അതിനാൽ, അത്
വായിക്കാൻ മാത്രമുള്ള മൂല്യങ്ങളിൽ ക്രോക്ക്സ്.

അസാധുവായ sv_force_normal_flags(SV *const sv,
const U32 പതാകകൾ)

sv_free ഒരു എസ്വിയുടെ റഫറൻസ് എണ്ണം കുറയ്ക്കുക, അത് പൂജ്യത്തിലേക്ക് താഴുകയാണെങ്കിൽ, "sv_clear" എന്ന് വിളിക്കുക
ഡിസ്ട്രക്റ്ററുകൾ അഭ്യർത്ഥിക്കുകയും ശരീരം ഉപയോഗിക്കുന്ന എല്ലാ മെമ്മറിയും സ്വതന്ത്രമാക്കുകയും ചെയ്യുക; ഒടുവിൽ, ഡീലോക്കേറ്റ് ചെയ്യുക
എസ് വിയുടെ തല തന്നെ. ഒരു റാപ്പർ മാക്രോ "SvREFCNT_dec" വഴിയാണ് സാധാരണയായി വിളിക്കുന്നത്.

ശൂന്യമായ sv_free(SV *const sv)

sv_gets ഫയൽഹാൻഡിൽ നിന്ന് ഒരു ലൈൻ നേടുകയും അത് SV-യിൽ സംഭരിക്കുകയും ചെയ്യുക, ഓപ്ഷണലായി ചേർക്കുക
നിലവിൽ സംഭരിച്ചിരിക്കുന്ന സ്ട്രിംഗ്. "അനുബന്ധം" 0 അല്ലെങ്കിൽ, വരി എസ്.വി
അത് തിരുത്തിയെഴുതുന്നതിന് പകരം. "append" എന്നത് ബൈറ്റ് ഓഫ്‌സെറ്റിലേക്ക് സജ്ജമാക്കണം
അനുബന്ധ സ്ട്രിംഗ് SV-യിൽ ആരംഭിക്കണം (സാധാരണയായി, "SvCUR(sv)" എന്നത് അനുയോജ്യമാണ്
തിരഞ്ഞെടുപ്പ്).

char* sv_gets(SV *const sv, PerlIO *const fp,
I32 അനുബന്ധം)

sv_get_backrefs
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

sv ഒരു ദുർബലമായ റഫറൻസിന്റെ ലക്ഷ്യമാണെങ്കിൽ, അത് ബാക്ക് റഫറൻസുകൾ നൽകുന്നു
എസ്വിയുമായി ബന്ധപ്പെട്ട ഘടന; അല്ലെങ്കിൽ NULL തിരികെ നൽകുക.

അസാധുവായ ഫലം നൽകുമ്പോൾ, റിട്ടേണിന്റെ തരം പ്രസക്തമാണ്. അത് ഒരു ആണെങ്കിൽ
AV അപ്പോൾ AV യുടെ ഘടകങ്ങൾ ബലഹീനമായ റഫറൻസ് RV-കൾ ആണ്
ഇനം. ഇത് മറ്റേതെങ്കിലും തരമാണെങ്കിൽ, ഇനം തന്നെ ദുർബലമായ റഫറൻസ് ആണ്.

ഇതും കാണുക Perl_sv_add_backref(), Perl_sv_del_backref(), Perl_sv_kill_backrefs()

SV* sv_get_backrefs(SV *const sv)

sv_grow എസ്‌വിയിലെ പ്രതീക ബഫർ വികസിപ്പിക്കുന്നു. ആവശ്യമെങ്കിൽ, "sv_unref" ഉപയോഗിക്കുന്നു ഒപ്പം
SV "SVt_PV" ലേക്ക് അപ്ഗ്രേഡ് ചെയ്യുന്നു. പ്രതീക ബഫറിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു. ഉപയോഗിക്കുക
പകരം "SvGROW" റാപ്പർ.

char* sv_grow(SV *const sv, STRLEN ന്യൂലെൻ)

sv_inc SV-യിലെ മൂല്യത്തിന്റെ സ്വയമേവ വർദ്ധനവ്, എങ്കിൽ സംഖ്യാ പരിവർത്തനത്തിലേക്ക് സ്ട്രിംഗ് ചെയ്യുന്നു
ആവശ്യമായ. 'ഗെറ്റ്' മാജിക്കും ഓപ്പറേറ്റർ ഓവർലോഡിംഗും കൈകാര്യം ചെയ്യുന്നു.

void sv_inc(SV *const sv)

sv_inc_nomg
SV-യിലെ മൂല്യത്തിന്റെ യാന്ത്രിക വർദ്ധനവ്, എങ്കിൽ സംഖ്യാ പരിവർത്തനത്തിലേക്ക് സ്ട്രിംഗ് ചെയ്യുന്നു
ആവശ്യമായ. ഓപ്പറേറ്റർ ഓവർലോഡിംഗ് കൈകാര്യം ചെയ്യുന്നു. 'ഗെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നത് ഒഴിവാക്കുന്നു.

void sv_inc_nomg(SV *const sv)

sv_insert
SV-യിൽ നിർദ്ദിഷ്‌ട ഓഫ്‌സെറ്റ്/ദൈർഘ്യത്തിൽ ഒരു സ്ട്രിംഗ് ചേർക്കുന്നു. എന്നതിന് സമാനമാണ്
പേൾ substr() പ്രവർത്തനം. ഹാൻഡിലുകൾക്ക് മാന്ത്രികത ലഭിക്കുന്നു.

void sv_insert(SV *const bigstr, const STRLEN ഓഫ്‌സെറ്റ്,
കോൺസ്റ്റ് STRLEN ലെൻ,
കോൺസ്റ്റ് ചാർ *കോൺസ്റ്റ് കുറച്ച്,
കോൺസ്റ്റ് STRLEN ലിറ്റിൽലെൻ)

sv_insert_flags
"sv_insert" പോലെ തന്നെ, എന്നാൽ അധിക "ഫ്ലാഗുകൾ" "SvPV_force_flags" ലേക്ക് കൈമാറുന്നു
അത് "bigstr" ന് ബാധകമാണ്.

void sv_insert_flags(SV *const bigstr,
const STRLEN ഓഫ്‌സെറ്റ്,
കോൺസ്റ്റ് STRLEN ലെൻ,
കോൺസ്റ്റ് ചാർ *കോൺസ്റ്റ് കുറച്ച്,
കോൺസ്റ്റ് STRLEN ലിറ്റിൽലെൻ,
const U32 പതാകകൾ)

sv_isa നിർദ്ദിഷ്‌ട ക്ലാസിലേക്ക് എസ്‌വി അനുഗ്രഹിക്കപ്പെട്ടിട്ടുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു.
ഇത് ഉപവിഭാഗങ്ങൾക്കായി പരിശോധിക്കുന്നില്ല; ഒരു അനന്തരാവകാശം പരിശോധിക്കാൻ "sv_derived_from" ഉപയോഗിക്കുക
ബന്ധം.

int sv_isa(SV* sv, const char *const name)

sv_isobject
അനുഗ്രഹിക്കപ്പെട്ട ഒരു വസ്തുവിലേക്ക് വിരൽ ചൂണ്ടുന്ന RV ആണോ SV എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂലിയൻ നൽകുന്നു.
എസ്‌വി ഒരു ആർവി അല്ലെങ്കിലോ ഒബ്‌ജക്റ്റ് അനുഗ്രഹിക്കപ്പെട്ടിട്ടില്ലെങ്കിലോ, ഇത് മടങ്ങിവരും
തെറ്റായ.

int sv_isobject(SV* sv)

sv_len SV-യിലെ സ്ട്രിംഗിന്റെ നീളം നൽകുന്നു. മാജിക്കും ടൈപ്പ് നിർബന്ധവും കൈകാര്യം ചെയ്യുന്നു
UTF8 ഫ്ലാഗ് ഉചിതമായി സജ്ജമാക്കുന്നു. ഇതിലേക്ക് റോ ആക്സസ് നൽകുന്ന "SvCUR" എന്നതും കാണുക
xpv_cur സ്ലോട്ട്.

STRLEN sv_len(SV *const sv)

sv_len_utf8
വിശാലമായ UTF-8 ബൈറ്റുകൾ എണ്ണിക്കൊണ്ട് ഒരു SV-യിലെ സ്‌ട്രിംഗിലെ പ്രതീകങ്ങളുടെ എണ്ണം നൽകുന്നു
ഒരൊറ്റ കഥാപാത്രമായി. മാന്ത്രികവും തരം ബലപ്രയോഗവും കൈകാര്യം ചെയ്യുന്നു.

STRLEN sv_len_utf8(SV *const sv)

sv_magic
ഒരു SV-യിലേക്ക് മാജിക് ചേർക്കുന്നു. ആവശ്യമെങ്കിൽ "SVt_PVMG" എന്ന് ടൈപ്പ് ചെയ്യുന്നതിന് ആദ്യം "sv" അപ്‌ഗ്രേഡ് ചെയ്യുക, തുടർന്ന്
മാജിക് ലിസ്റ്റിന്റെ തലയിലേക്ക് "എങ്ങനെ" എന്ന തരത്തിലുള്ള ഒരു പുതിയ മാജിക് ഇനം ചേർക്കുന്നു.

കൈകാര്യം ചെയ്യലിന്റെ വിവരണത്തിനായി "sv_magicext" ("sv_magic" ഇപ്പോൾ വിളിക്കുന്നു) കാണുക
"പേര്", "നാംലെൻ" എന്നീ ആർഗ്യുമെന്റുകളുടെ.

SvREADONLY SV-കളിലേക്ക് മാജിക് ചേർക്കാനും കൂടുതൽ ചേർക്കാനും നിങ്ങൾ "sv_magicext" ഉപയോഗിക്കേണ്ടതുണ്ട്
അതേ 'എങ്ങനെ' എന്നതിന്റെ ഒരു ഉദാഹരണത്തേക്കാൾ.

void sv_magic(SV *const sv, SV *const obj,
const int how, const char *const name,
const I32 namlen)

sv_magicext
ഒരു SV-യിലേക്ക് മാജിക് ചേർക്കുന്നു, ആവശ്യമെങ്കിൽ അത് നവീകരിക്കുന്നു. വിതരണം ചെയ്ത vtable പ്രയോഗിക്കുന്നു ഒപ്പം
ചേർത്ത മാജിക്കിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു.

"sv_magic" അനുവദിക്കാത്ത കാര്യങ്ങൾ "sv_magicext" അനുവദിക്കുമെന്നത് ശ്രദ്ധിക്കുക. ഇൻ
പ്രത്യേകിച്ചും, നിങ്ങൾക്ക് SvREADONLY SV-കളിൽ മാജിക് ചേർക്കാനും ഒന്നിൽ കൂടുതൽ ഉദാഹരണങ്ങൾ ചേർക്കാനും കഴിയും
അതേ 'എങ്ങനെ'.

"namlen" പൂജ്യത്തേക്കാൾ വലുതാണെങ്കിൽ ഒരു "savepvn" പകർത്തുക എങ്കിൽ "പേര്" സംഭരിച്ചിരിക്കുന്നു
"namlen" എന്നത് പൂജ്യമാണ്, തുടർന്ന് "പേര്" അതേപടി സംഭരിക്കുന്നു - മറ്റൊരു പ്രത്യേക സന്ദർഭമായി - എങ്കിൽ
"(name && namlen == HEf_SVKEY)" തുടർന്ന് "പേര്" എന്നതിൽ ഒരു "SV*" അടങ്ങിയിരിക്കുന്നതായി അനുമാനിക്കപ്പെടുന്നു.
REFCNT വർദ്ധിപ്പിച്ചത് പോലെ സംഭരിക്കുന്നു.

(ഇത് ഇപ്പോൾ "sv_magic" ഒരു സബ്റൂട്ടീനായി ഉപയോഗിക്കുന്നു.)

MAGIC * sv_magicext(SV *const sv, SV *const obj,
const int എങ്ങനെ,
const MGVTBL *const vtbl,
കോൺസ്റ്റ് ചാർ * കോൺസ്റ്റ് നാമം,
const I32 namlen)

sv_mortalcopy
യഥാർത്ഥ എസ്‌വിയുടെ പകർപ്പായ ഒരു പുതിയ എസ്‌വി സൃഷ്‌ടിക്കുന്നു ("sv_setsv" ഉപയോഗിച്ച്). പുതിയ
എസ് വിയെ മർത്യനായി അടയാളപ്പെടുത്തിയിരിക്കുന്നു. ഇത് "ഉടൻ" നശിപ്പിക്കപ്പെടും, ഒന്നുകിൽ ഒരു വ്യക്തമായ കോളിലൂടെ
FREETMPS-ലേക്ക്, അല്ലെങ്കിൽ പ്രസ്താവന അതിരുകൾ പോലുള്ള സ്ഥലങ്ങളിൽ ഒരു പരോക്ഷ കോൾ വഴി. കാണുക
"sv_newmortal", "sv_2mortal" എന്നിവയും.

SV* sv_mortalcopy(SV *const oldsv)

sv_newmortal
മാരകമായ ഒരു പുതിയ null SV സൃഷ്ടിക്കുന്നു. SV-യുടെ റഫറൻസ് എണ്ണം 1 ആയി സജ്ജീകരിച്ചിരിക്കുന്നു.
ഒന്നുകിൽ FREETMPS-ലേക്കുള്ള വ്യക്തമായ കോളിലൂടെയോ അല്ലെങ്കിൽ ഒരു വഴിയോ "ഉടൻ" ഇത് നശിപ്പിക്കപ്പെടും
പ്രസ്താവന അതിരുകൾ പോലുള്ള സ്ഥലങ്ങളിൽ പരോക്ഷമായ കോൾ. "sv_mortalcopy" എന്നതും കാണുക
കൂടാതെ "sv_2mortal".

SV* sv_newmortal()

sv_newref
ഒരു എസ്വിയുടെ റഫറൻസ് എണ്ണം വർദ്ധിപ്പിക്കുക. പകരം "SvREFCNT_inc()" റാപ്പർ ഉപയോഗിക്കുക.

SV* sv_newref(SV *const sv)

sv_pos_b2u
ആരംഭം മുതൽ ബൈറ്റുകളുടെ എണ്ണത്തിൽ നിന്ന് ഓഫ്‌സെറ്റ് ചൂണ്ടിക്കാണിച്ച മൂല്യം പരിവർത്തനം ചെയ്യുന്നു
സ്ട്രിംഗ്, UTF-8 പ്രതീകങ്ങളുടെ തുല്യ സംഖ്യയുടെ എണ്ണത്തിലേക്ക്. മാജിക് കൈകാര്യം ചെയ്യുന്നു ഒപ്പം
തരം നിർബന്ധം.

മുൻ‌ഗണനയിൽ "sv_pos_b2u_flags" ഉപയോഗിക്കുക, ഇത് കൂടുതൽ നീളമുള്ള സ്ട്രിംഗുകൾ ശരിയായി കൈകാര്യം ചെയ്യുന്നു
2 ജിബി.

void sv_pos_b2u(SV *const sv, I32 *const offsetp)

sv_pos_b2u_flags
സ്‌ട്രിംഗിന്റെ ആരംഭം മുതൽ ബൈറ്റുകളുടെ എണ്ണത്തിൽ നിന്ന് ഒരു എണ്ണത്തിലേക്ക് ഓഫ്‌സെറ്റ് പരിവർത്തനം ചെയ്യുന്നു
UTF-8 അക്ഷരങ്ങളുടെ തുല്യ സംഖ്യയുടെ. തരം ബലപ്രയോഗം കൈകാര്യം ചെയ്യുന്നു. ഫ്ലാഗുകൾ പാസ്സായി
"SvPV_flags" എന്നതിലേക്ക്, സാധാരണയായി കൈകാര്യം ചെയ്യാൻ "SV_GMAGIC|SV_CONST_RETURN" ആയിരിക്കണം
ജാലവിദ്യ.

STRLEN sv_pos_b2u_flags(SV *const sv,
STRLEN കോൺസ്റ്റ് ഓഫ്‌സെറ്റ്, U32 ഫ്ലാഗുകൾ)

sv_pos_u2b
എന്നതിൽ നിന്നുള്ള UTF-8 പ്രതീകങ്ങളുടെ എണ്ണത്തിൽ നിന്ന് ഓഫ്‌സെറ്റ് ചൂണ്ടിക്കാണിച്ച മൂല്യം പരിവർത്തനം ചെയ്യുന്നു
സ്ട്രിംഗിന്റെ ആരംഭം, തുല്യമായ ബൈറ്റുകളുടെ എണ്ണത്തിലേക്ക്; ലെൻപ് അല്ലാത്തതാണെങ്കിൽ
പൂജ്യം, ഇത് lenp-ന് സമാനമാണ്, എന്നാൽ ഇത്തവണ ഓഫ്‌സെറ്റിൽ നിന്ന് ആരംഭിക്കുന്നു
സ്ട്രിംഗിന്റെ തുടക്കം മുതലുള്ളതിനേക്കാൾ. മാന്ത്രികവും തരം ബലപ്രയോഗവും കൈകാര്യം ചെയ്യുന്നു.

മുൻ‌ഗണനയിൽ "sv_pos_u2b_flags" ഉപയോഗിക്കുക, ഇത് കൂടുതൽ നീളമുള്ള സ്ട്രിംഗുകൾ ശരിയായി കൈകാര്യം ചെയ്യുന്നു
2 ജിബി.

void sv_pos_u2b(SV *const sv, I32 *const offsetp,
I32 *const lenp)

sv_pos_u2b_flags
സ്ട്രിംഗിന്റെ തുടക്കം മുതൽ UTF-8 അക്ഷരങ്ങളുടെ എണ്ണത്തിൽ നിന്ന് ഓഫ്‌സെറ്റ് പരിവർത്തനം ചെയ്യുന്നു, a
തുല്യമായ ബൈറ്റുകളുടെ എണ്ണം; lenp പൂജ്യമല്ലെങ്കിൽ, അതും ചെയ്യുന്നു
lenp, എന്നാൽ ഇത്തവണ ഓഫ്സെറ്റിൽ നിന്ന് ആരംഭിക്കുന്നു, പകരം ന്റെ തുടക്കത്തിൽ നിന്ന്
സ്ട്രിംഗ്. തരം ബലപ്രയോഗം കൈകാര്യം ചെയ്യുന്നു. ഫ്ലാഗുകൾ "SvPV_flags"-ലേക്ക് കൈമാറുന്നു, സാധാരണയായി
മാജിക് കൈകാര്യം ചെയ്യാൻ "SV_GMAGIC|SV_CONST_RETURN" ആയിരിക്കണം.

STRLEN sv_pos_u2b_flags(SV *const sv, STRLEN uoffset,
STRLEN *const lenp, U32 ഫ്ലാഗുകൾ)

sv_pvbyten_force
"SvPVbytex_force" മാക്രോയുടെ ബാക്കെൻഡ്. പകരം എപ്പോഴും മാക്രോ ഉപയോഗിക്കുക.

char* sv_pvbyten_force(SV *const sv, STRLEN *const lp)

sv_pvn_force
എങ്ങനെയെങ്കിലും എസ്‌വിയിൽ നിന്ന് വിവേകപൂർണ്ണമായ ഒരു സ്ട്രിംഗ് പുറത്തെടുക്കുക. യുടെ ഒരു സ്വകാര്യ നടപ്പാക്കൽ
സങ്കീർണ്ണമായ മാക്രോ എക്സ്പ്രഷനുകളെ നേരിടാൻ കഴിയാത്ത കംപൈലറുകൾക്കായുള്ള "SvPV_force" മാക്രോ.
പകരം എപ്പോഴും മാക്രോ ഉപയോഗിക്കുക.

char* sv_pvn_force(SV* sv, STRLEN* lp)

sv_pvn_force_flags
എങ്ങനെയെങ്കിലും എസ്‌വിയിൽ നിന്ന് വിവേകപൂർണ്ണമായ ഒരു സ്ട്രിംഗ് പുറത്തെടുക്കുക. "ഫ്ലാഗുകൾക്ക്" "SV_GMAGIC" ബിറ്റ് സെറ്റ് ഉണ്ടെങ്കിൽ,
ഉചിതമെങ്കിൽ "sv"-ൽ "mg_get" ചെയ്യും, അല്ലാത്തപക്ഷം. "sv_pvn_force" കൂടാതെ
ഈ ഫംഗ്‌ഷന്റെ അടിസ്ഥാനത്തിൽ "sv_pvn_force_nomg" നടപ്പിലാക്കുന്നു. നിങ്ങൾ സാധാരണയായി ആഗ്രഹിക്കുന്നു
പകരം വിവിധ റാപ്പർ മാക്രോകൾ ഉപയോഗിക്കുന്നതിന്: "SvPV_force", "SvPV_force_nomg" എന്നിവ കാണുക

char* sv_pvn_force_flags(SV *const sv,
STRLEN *const lp,
const I32 പതാകകൾ)

sv_pvutf8n_force
"SvPVutf8x_force" മാക്രോയുടെ ബാക്കെൻഡ്. പകരം എപ്പോഴും മാക്രോ ഉപയോഗിക്കുക.

char* sv_pvutf8n_force(SV *const sv, STRLEN *const lp)

sv_reftype
SV ഒരു റഫറൻസ് എന്താണെന്ന് വിവരിക്കുന്ന ഒരു സ്ട്രിംഗ് നൽകുന്നു.

const char* sv_reftype(const SV *const sv, const int ob)

sv_replace
ആദ്യത്തെ ആർഗ്യുമെന്റ് രണ്ടാമത്തേതിന്റെ പകർപ്പ് ആക്കുക, തുടർന്ന് ഒറിജിനൽ ഇല്ലാതാക്കുക. ദി
ടാർഗെറ്റ് എസ്വി, സ്രോതസ് എസ്വിയുടെ ബോഡിയുടെ ഉടമസ്ഥാവകാശം ഭൗതികമായി ഏറ്റെടുക്കുന്നു
അതിന്റെ പതാകകൾ അവകാശമാക്കുന്നു; എന്നിരുന്നാലും, ലക്ഷ്യം അതിന്റെ ഉടമസ്ഥതയിലുള്ള ഏത് മാന്ത്രികതയും ഏത് മാന്ത്രികതയിലും സൂക്ഷിക്കുന്നു
ഉറവിടം ഉപേക്ഷിച്ചു. ഇതൊരു സ്പെഷ്യലിസ്റ്റ് എസ്വി പകർത്തലാണെന്ന കാര്യം ശ്രദ്ധിക്കുക
ഓപ്പറേഷൻ; മിക്കപ്പോഴും നിങ്ങൾ "sv_setsv" അല്ലെങ്കിൽ അതിന്റെ നിരവധി മാക്രോകളിൽ ഒന്ന് ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നു
മുൻഭാഗങ്ങൾ.

അസാധുവായ sv_replace(SV *const sv, SV *const nsv)

sv_reset
"റീസെറ്റ്" പേൾ ഫംഗ്‌ഷന്റെ അടിസ്ഥാനപരമായ നടപ്പാക്കൽ. പേൾ-ലെവൽ എന്നത് ശ്രദ്ധിക്കുക
പ്രവർത്തനം അവ്യക്തമായി ഒഴിവാക്കിയിരിക്കുന്നു.

അസാധുവായ sv_reset(const char* s, HV *const stash)

sv_rvweaken
ഒരു റഫറൻസ് ദുർബലമാക്കുക: ഈ ആർവിയിൽ "SvWEAKREF" ഫ്ലാഗ് സജ്ജമാക്കുക; റഫർ ചെയ്ത എസ്.വി
"PERL_MAGIC_backref" മാജിക് ഇതുവരെ ഇല്ലെങ്കിൽ; ഇതിലേക്ക് ഒരു ബാക്ക് റഫറൻസ് തള്ളുകയും ചെയ്യുക
ആ മാജിക്കുമായി ബന്ധപ്പെട്ട ബാക്ക് റഫറൻസുകളുടെ നിരയിലേക്ക് ആർവി. ആർവി ആണെങ്കിൽ
ആർവി മായ്‌ച്ചതിന് ശേഷം മാന്ത്രിക, സെറ്റ് മാജിക് വിളിക്കും.

SV* sv_rvweaken(SV *const sv)

sv_setiv
നൽകിയിരിക്കുന്ന SV-യിലേക്ക് ഒരു പൂർണ്ണസംഖ്യ പകർത്തുന്നു, ആവശ്യമെങ്കിൽ ആദ്യം നവീകരിക്കുന്നു. ഇല്ല
'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുക. "sv_setiv_mg" എന്നതും കാണുക.

ശൂന്യമായ sv_setiv(SV *const sv, const IV സംഖ്യ)

sv_setiv_mg
"sv_setiv" പോലെ, മാത്രമല്ല 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു.

void sv_setiv_mg(SV *const sv, const IV i)

sv_setnv
നൽകിയിരിക്കുന്ന SV-യിലേക്ക് ഇരട്ടി പകർത്തുന്നു, ആവശ്യമെങ്കിൽ ആദ്യം നവീകരിക്കുന്നു. കൈകാര്യം ചെയ്യുന്നില്ല
'സെറ്റ്' മാജിക്. "sv_setnv_mg" എന്നതും കാണുക.

അസാധുവായ sv_setnv(SV *const sv, const NV സംഖ്യ)

sv_setnv_mg
"sv_setnv" പോലെ, മാത്രമല്ല 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു.

void sv_setnv_mg(SV *const sv, const NV സംഖ്യ)

sv_setpv
ഒരു സ്ട്രിംഗ് ഒരു SV-യിലേക്ക് പകർത്തുന്നു. സ്ട്രിംഗ് ഒരു "NUL" പ്രതീകം ഉപയോഗിച്ച് അവസാനിപ്പിക്കണം.
'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നില്ല. "sv_setpv_mg" കാണുക.

അസാധുവായ sv_setpv(SV *const sv, const char *const ptr)

sv_setpvf
"sv_catpvf" പോലെ പ്രവർത്തിക്കുന്നു, പക്ഷേ ടെക്‌സ്‌റ്റ് കൂട്ടിച്ചേർക്കുന്നതിന് പകരം SV-യിലേക്ക് പകർത്തുന്നു.
'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നില്ല. "sv_setpvf_mg" കാണുക.

void sv_setpvf(SV *const sv, const char *const pat,
...)

sv_setpvf_mg
"sv_setpvf" പോലെ, മാത്രമല്ല 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു.

ശൂന്യമായ sv_setpvf_mg(SV *const sv,
കോൺസ്റ്റ് ചാർ *കോൺസ്റ്റ് പാറ്റ്, ...)

sv_setpviv
തന്നിരിക്കുന്ന SV-യിലേക്ക് ഒരു പൂർണ്ണസംഖ്യ പകർത്തുന്നു, അതിന്റെ സ്ട്രിംഗ് മൂല്യവും അപ്ഡേറ്റ് ചെയ്യുന്നു. ഇല്ല
'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുക. "sv_setpviv_mg" കാണുക.

ശൂന്യമായ sv_setpviv(SV *const sv, const IV സംഖ്യ)

sv_setpviv_mg
"sv_setpviv" പോലെ, മാത്രമല്ല 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു.

അസാധുവായ sv_setpviv_mg(SV *const sv, const IV iv)

sv_setpvn
ഒരു സ്ട്രിംഗ് (ഒരുപക്ഷേ ഉൾച്ചേർത്ത "NUL" പ്രതീകങ്ങൾ അടങ്ങിയിരിക്കാം) ഒരു SV-യിലേക്ക് പകർത്തുന്നു. ദി
"len" പാരാമീറ്റർ പകർത്തേണ്ട ബൈറ്റുകളുടെ എണ്ണം സൂചിപ്പിക്കുന്നു. "ptr" വാദം ആണെങ്കിൽ
NULL ആണെങ്കിൽ SV അവ്യക്തമാകും. 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നില്ല. കാണുക
"sv_setpvn_mg".

void sv_setpvn(SV *const sv, const char *const ptr,
കോൺസ്റ്റ് STRLEN ലെൻ)

sv_setpvn_mg
"sv_setpvn" പോലെ, മാത്രമല്ല 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു.

ശൂന്യമായ sv_setpvn_mg(SV *const sv,
const char *const ptr,
കോൺസ്റ്റ് STRLEN ലെൻ)

sv_setpvs
"sv_setpvn" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/ലെങ്ത്ത് ജോഡിക്ക് പകരം ഒരു ലിറ്ററൽ സ്ട്രിംഗ് എടുക്കുന്നു.

അസാധുവായ sv_setpvs(SV* sv, const char* s)

sv_setpvs_mg
"sv_setpvn_mg" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/നീളമുള്ള ജോഡിക്ക് പകരം ഒരു ലിറ്ററൽ സ്ട്രിംഗ് എടുക്കുന്നു.

അസാധുവായ sv_setpvs_mg(SV* sv, const char* s)

sv_setpv_mg
"sv_setpv" പോലെ, എന്നാൽ 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു.

void sv_setpv_mg(SV *const sv, const char *const ptr)

sv_setref_iv
ഒരു പുതിയ SV-യിലേക്ക് ഒരു പൂർണ്ണസംഖ്യ പകർത്തുന്നു, ഓപ്ഷണലായി SV-യെ അനുഗ്രഹിക്കുന്നു. "rv" വാദം
ഒരു RV ആയി അപ്ഗ്രേഡ് ചെയ്യും. പുതിയ എസ്‌വിയിലേക്ക് ചൂണ്ടിക്കാണിക്കാൻ ആ ആർവി പരിഷ്‌കരിക്കും. ദി
"classname" വാദം അനുഗ്രഹത്തിനായുള്ള പാക്കേജിനെ സൂചിപ്പിക്കുന്നു. "ക്ലാസ്‌നെയിം" എന്ന് സജ്ജീകരിക്കുക
അനുഗ്രഹം ഒഴിവാക്കാൻ "NULL". പുതിയ എസ്‌വിക്ക് 1 റഫറൻസ് കൗണ്ട് ഉണ്ടായിരിക്കും
RV തിരികെ നൽകും.

SV* sv_setref_iv(SV *const rv,
കോൺസ്റ്റ് ചാർ * കോൺസ്റ്റ് ക്ലാസ് നാമം,
const IV iv)

sv_setref_nv
ഒരു പുതിയ SV-യിലേക്ക് ഇരട്ടി പകർത്തുന്നു, ഓപ്ഷണലായി SV-യെ അനുഗ്രഹിക്കുന്നു. "rv" വാദം ചെയ്യും
ഒരു RV ലേക്ക് അപ്ഗ്രേഡ് ചെയ്യപ്പെടും. പുതിയ എസ്‌വിയിലേക്ക് ചൂണ്ടിക്കാണിക്കാൻ ആ ആർവി പരിഷ്‌കരിക്കും. ദി
"classname" വാദം അനുഗ്രഹത്തിനായുള്ള പാക്കേജിനെ സൂചിപ്പിക്കുന്നു. "ക്ലാസ്‌നെയിം" എന്ന് സജ്ജീകരിക്കുക
അനുഗ്രഹം ഒഴിവാക്കാൻ "NULL". പുതിയ എസ്‌വിക്ക് 1 റഫറൻസ് കൗണ്ട് ഉണ്ടായിരിക്കും
RV തിരികെ നൽകും.

SV* sv_setref_nv(SV *const rv,
കോൺസ്റ്റ് ചാർ * കോൺസ്റ്റ് ക്ലാസ് നാമം,
const NV nv)

sv_setref_pv
ഒരു പുതിയ എസ്‌വിയിലേക്ക് ഒരു പോയിന്റർ പകർത്തുന്നു, ഓപ്‌ഷണലായി എസ്‌വിയെ അനുഗ്രഹിക്കുന്നു. "rv" വാദം
ഒരു RV ആയി അപ്ഗ്രേഡ് ചെയ്യും. പുതിയ എസ്‌വിയിലേക്ക് ചൂണ്ടിക്കാണിക്കാൻ ആ ആർവി പരിഷ്‌കരിക്കും. എങ്കിൽ
"pv" ആർഗ്യുമെന്റ് NULL ആണെങ്കിൽ "PL_sv_undef" SV-യിൽ സ്ഥാപിക്കും. ദി
"classname" വാദം അനുഗ്രഹത്തിനായുള്ള പാക്കേജിനെ സൂചിപ്പിക്കുന്നു. "ക്ലാസ്‌നെയിം" എന്ന് സജ്ജീകരിക്കുക
അനുഗ്രഹം ഒഴിവാക്കാൻ "NULL". പുതിയ എസ്‌വിക്ക് 1 റഫറൻസ് കൗണ്ട് ഉണ്ടായിരിക്കും
RV തിരികെ നൽകും.

HV, AV, SV, CV പോലുള്ള മറ്റ് Perl തരങ്ങൾക്കൊപ്പം ഉപയോഗിക്കരുത്, കാരണം ആ ഒബ്‌ജക്റ്റുകൾ
പോയിന്റർ കോപ്പി പ്രക്രിയ വഴി കേടാകും.

ഇത് പോയിന്റർ പകർത്തുമ്പോൾ "sv_setref_pvn" സ്ട്രിംഗ് പകർത്തുന്നു എന്നത് ശ്രദ്ധിക്കുക.

SV* sv_setref_pv(SV *const rv,
കോൺസ്റ്റ് ചാർ * കോൺസ്റ്റ് ക്ലാസ് നാമം,
അസാധുവായ * കോൺസ്റ്റ് പിവി)

sv_setref_pvn
ഒരു പുതിയ SV-യിലേക്ക് ഒരു സ്ട്രിംഗ് പകർത്തുന്നു, ഓപ്ഷണലായി SV-യെ അനുഗ്രഹിക്കുന്നു. യുടെ നീളം
സ്ട്രിംഗ് "n" ഉപയോഗിച്ച് വ്യക്തമാക്കണം. "rv" ആർഗ്യുമെന്റ് ഒരു RV ആയി അപ്ഗ്രേഡ് ചെയ്യും.
പുതിയ എസ്‌വിയിലേക്ക് ചൂണ്ടിക്കാണിക്കാൻ ആ ആർവി പരിഷ്‌കരിക്കും. "ക്ലാസ് നെയിം" വാദം
അനുഗ്രഹത്തിനുള്ള പാക്കേജ് സൂചിപ്പിക്കുന്നു. ഒഴിവാക്കാൻ "ക്ലാസ്‌നെയിം" "NULL" ആയി സജ്ജീകരിക്കുക
അനുഗ്രഹം. പുതിയ എസ്‌വിക്ക് 1 റഫറൻസ് കൗണ്ട് ഉണ്ടായിരിക്കും, കൂടാതെ ആർവിയും ആയിരിക്കും
മടങ്ങി.

ഇത് സ്ട്രിംഗ് പകർത്തുമ്പോൾ "sv_setref_pv" പോയിന്റർ പകർത്തുന്നു എന്നത് ശ്രദ്ധിക്കുക.

SV* sv_setref_pvn(SV *const rv,
കോൺസ്റ്റ് ചാർ * കോൺസ്റ്റ് ക്ലാസ് നാമം,
കോൺസ്റ്റ് ചാർ *കോൺസ്റ്റ് പിവി,
കോൺസ്റ്റ് STRLEN n)

sv_setref_pvs
"sv_setref_pvn" പോലെ, എന്നാൽ ഒരു സ്ട്രിംഗ്/നീള ജോഡിക്ക് പകരം ഒരു അക്ഷര സ്ട്രിംഗ് എടുക്കുന്നു.

SV * sv_setref_pvs(const char* s)

sv_setref_uv
ഒരു പുതിയ SV-യിലേക്ക് ഒപ്പിടാത്ത ഒരു പൂർണ്ണസംഖ്യ പകർത്തുന്നു, ഓപ്ഷണലായി SV-യെ അനുഗ്രഹിക്കുന്നു. "rv"
ആർഗ്യുമെന്റ് ഒരു RV ആയി അപ്‌ഗ്രേഡ് ചെയ്യും. പുതിയതിലേക്ക് വിരൽ ചൂണ്ടാൻ ആ ആർവി പരിഷ്കരിക്കും
എസ്.വി. "ക്ലാസ്നെയിം" ആർഗ്യുമെന്റ് അനുഗ്രഹത്തിനുള്ള പാക്കേജിനെ സൂചിപ്പിക്കുന്നു. സജ്ജമാക്കുക
അനുഗ്രഹം ഒഴിവാക്കാൻ "ക്ലാസ്‌നെയിം" "NULL" ആക്കുക. പുതിയ എസ്വിക്ക് ഒരു റഫറൻസ് ഉണ്ടായിരിക്കും
1 എണ്ണം, RV തിരികെ നൽകും.

SV* sv_setref_uv(SV *const rv,
കോൺസ്റ്റ് ചാർ * കോൺസ്റ്റ് ക്ലാസ് നാമം,
const UV uv)

sv_setv
ഉറവിടം SV "ssv" യുടെ ഉള്ളടക്കം SV "dsv" എന്ന ലക്ഷ്യസ്ഥാനത്തേക്ക് പകർത്തുന്നു. ദി
സ്രോതസ്സ് എസ്വി മാരകമാണെങ്കിൽ നശിപ്പിക്കപ്പെടാം, അതിനാൽ ഈ ഫംഗ്ഷൻ ഉപയോഗിക്കരുത്
ഉറവിട എസ്വി വീണ്ടും ഉപയോഗിക്കേണ്ടതുണ്ട്. ലക്ഷ്യസ്ഥാനമായ SV-യിൽ 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നില്ല.
സോഴ്‌സ് എസ്‌വിയിൽ കോളുകൾ 'ഗെറ്റ്' മാജിക്. ലളിതമായി പറഞ്ഞാൽ, അത് ഒരു കോപ്പി-ബൈ-വാല്യൂ നിർവഹിക്കുന്നു,
ലക്ഷ്യസ്ഥാനത്തിന്റെ മുമ്പത്തെ ഏതെങ്കിലും ഉള്ളടക്കം ഇല്ലാതാക്കുന്നു.

"SvSetSV" പോലെയുള്ള റാപ്പറുകളുടെ ശേഖരത്തിൽ ഒന്ന് ഉപയോഗിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം,
"SvSetSV_nosteal", "SvSetMagicSV", "SvSetMagicSV_nosteal".

അസാധുവായ sv_setsv(SV *dstr, SV *sstr)

sv_setsv_flags
ഉറവിടം SV "ssv" യുടെ ഉള്ളടക്കം SV "dsv" എന്ന ലക്ഷ്യസ്ഥാനത്തേക്ക് പകർത്തുന്നു. ദി
സ്രോതസ്സ് എസ്വി മാരകമാണെങ്കിൽ നശിപ്പിക്കപ്പെടാം, അതിനാൽ ഈ ഫംഗ്ഷൻ ഉപയോഗിക്കരുത്
ഉറവിട എസ്വി വീണ്ടും ഉപയോഗിക്കേണ്ടതുണ്ട്. 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നില്ല. ചുരുക്കി പറഞ്ഞാൽ, അത്
ലക്ഷ്യസ്ഥാനത്തിന്റെ മുമ്പത്തെ ഏതെങ്കിലും ഉള്ളടക്കം ഇല്ലാതാക്കിക്കൊണ്ട് ഒരു കോപ്പി-ബൈ-വാല്യൂ നടത്തുന്നു.
"ഫ്ലാഗ്സ്" പാരാമീറ്ററിൽ "SV_GMAGIC" ബിറ്റ് സെറ്റ് ഉണ്ടെങ്കിൽ, "ssv" ൽ "mg_get" ആകും
ഉചിതം, അല്ലാത്തത്. "ഫ്ലാഗുകൾ" പരാമീറ്ററിൽ "SV_NOSTEAL" ബിറ്റ് സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ
ടെമ്പുകളുടെ ബഫറുകൾ മോഷ്ടിക്കപ്പെടുകയില്ല. "sv_setsv_nomg" എന്നിവയും
ഈ പ്രവർത്തനത്തിന്റെ അടിസ്ഥാനത്തിൽ നടപ്പിലാക്കി.

"SvSetSV" പോലെയുള്ള റാപ്പറുകളുടെ ശേഖരത്തിൽ ഒന്ന് ഉപയോഗിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം,
"SvSetSV_nosteal", "SvSetMagicSV", "SvSetMagicSV_nosteal".

സ്കെയിലറുകളും മറ്റ് മിക്ക കോപ്പി-ഇഷും പകർത്തുന്നതിനുള്ള പ്രാഥമിക പ്രവർത്തനമാണിത്
ഫംഗ്ഷനുകളും മാക്രോകളും ഇത് ചുവടെ ഉപയോഗിക്കുന്നു.

അസാധുവായ sv_setsv_flags(SV *dstr, SV *sstr,
const I32 പതാകകൾ)

sv_setsv_mg
"sv_setsv" പോലെ, എന്നാൽ 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു.

void sv_setsv_mg(SV *const dstr, SV *const sstr)

sv_setuv
നൽകിയിരിക്കുന്ന SV-യിലേക്ക് ഒപ്പിടാത്ത ഒരു പൂർണ്ണസംഖ്യ പകർത്തുന്നു, ആവശ്യമെങ്കിൽ ആദ്യം നവീകരിക്കുന്നു. ചെയ്യുന്നു
'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യരുത്. "sv_setuv_mg" എന്നതും കാണുക.

അസാധുവായ sv_setuv(SV *const sv, const UV സംഖ്യ)

sv_setuv_mg
"sv_setuv" പോലെ, മാത്രമല്ല 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു.

void sv_setuv_mg(SV *const sv, const UV u)

sv_ കളങ്കം
കറകളഞ്ഞതിനായി ഒരു SV പരിശോധിക്കുക. പകരം "SvTAINTED" ഉപയോഗിക്കുക.

bool sv_tainted(SV *const sv)

sv_true പേളിന്റെ നിയമങ്ങൾ പ്രകാരം എസ്വിക്ക് യഥാർത്ഥ മൂല്യമുണ്ടെങ്കിൽ true എന്ന് നൽകുന്നു. "SvTRUE" മാക്രോ ഉപയോഗിക്കുക
പകരം, അത് "sv_true()" എന്ന് വിളിക്കാം അല്ലെങ്കിൽ പകരം ഒരു ഇൻ-ലൈൻ പതിപ്പ് ഉപയോഗിക്കാം.

I32 sv_true(SV *const sv)

sv_unmagic
ഒരു SV-യിൽ നിന്ന് "ടൈപ്പ്" എന്ന തരത്തിലുള്ള എല്ലാ മാന്ത്രികതകളും നീക്കംചെയ്യുന്നു.

int sv_unmagic(SV *const sv, const int തരം)

sv_unmagicext
ഒരു SV-യിൽ നിന്ന് നിർദ്ദിഷ്ട "vtbl" ഉപയോഗിച്ച് "ടൈപ്പ്" തരത്തിന്റെ എല്ലാ മാന്ത്രികതകളും നീക്കംചെയ്യുന്നു.

int sv_unmagicext(SV *const sv, const int തരം,
MGVTBL *vtbl)

sv_unref_flags
SV-യുടെ RV സ്റ്റാറ്റസ് അൺസെറ്റ് ചെയ്യുന്നു, കൂടാതെ എന്തായിരുന്നാലും അതിന്റെ റഫറൻസ് എണ്ണം കുറയ്ക്കുന്നു
RV പരാമർശിക്കുന്നു. ഇത് ഏതാണ്ട് വിപരീതമായി കണക്കാക്കാം
"newSVrv". "cflags" ആർഗ്യുമെന്റിൽ "SV_IMMEDIATE_UNREF" അടങ്ങിയിരിക്കാം
റഫറൻസ് എണ്ണം കുറയ്ക്കണം (അല്ലെങ്കിൽ കുറയുന്നത് സോപാധികമാണ്
റഫറൻസ് എണ്ണം ഒന്നിൽ നിന്ന് വ്യത്യസ്തമാണ് അല്ലെങ്കിൽ റഫറൻസ് വായിക്കാൻ മാത്രമുള്ളതാണ്
എസ്.വി). "SvROK_off" കാണുക.

void sv_unref_flags(SV *const ref, const U32 ഫ്ലാഗുകൾ)

sv_untaint
ഒരു എസ്‌വി അൺടൈൻറ്റ് ചെയ്യുക. പകരം "SvTAINTED_off" ഉപയോഗിക്കുക.

void sv_untaint(SV *const sv)

sv_upgrade
ഒരു SV കൂടുതൽ സങ്കീർണ്ണമായ ഒരു രൂപത്തിലേക്ക് അപ്ഗ്രേഡ് ചെയ്യുക. സാധാരണയായി SV-യിലേക്ക് ഒരു പുതിയ ബോഡി തരം ചേർക്കുന്നു,
തുടർന്ന് പഴയ ബോഡിയിൽ നിന്ന് കഴിയുന്നത്ര വിവരങ്ങൾ പകർത്തുന്നു. അത് കരയുന്നു
SV ഇതിനകം ആവശ്യപ്പെട്ടതിലും കൂടുതൽ സങ്കീർണ്ണമായ രൂപത്തിലാണെങ്കിൽ. നിങ്ങൾ സാധാരണയായി ആഗ്രഹിക്കുന്നു
വിളിക്കുന്നതിന് മുമ്പ് തരം പരിശോധിക്കുന്ന "SvUPGRADE" മാക്രോ റാപ്പർ ഉപയോഗിക്കുക
"sv_upgrade", അതിനാൽ ക്രോക്ക് ചെയ്യുന്നില്ല. "svtype" എന്നതും കാണുക.

void sv_upgrade(SV *const sv, svtype new_type)

sv_usepvn_flags
ഒരു എസ്വിയോട് അതിന്റെ സ്ട്രിംഗ് മൂല്യം കണ്ടെത്താൻ "ptr" ഉപയോഗിക്കാൻ പറയുന്നു. സാധാരണയായി സ്ട്രിംഗ് സൂക്ഷിക്കുന്നു
SV-യുടെ ഉള്ളിൽ, എന്നാൽ sv_usepvn ഒരു ബാഹ്യ സ്ട്രിംഗ് ഉപയോഗിക്കാൻ SV-യെ അനുവദിക്കുന്നു. "ptr"
ന്യൂക്സ് അനുവദിച്ച മെമ്മറിയിലേക്ക് ചൂണ്ടിക്കാണിക്കണം. എ യുടെ തുടക്കമായിരിക്കണം
മെമ്മറിയുടെ ന്യൂക്‌സ്-എഡ് ബ്ലോക്ക്, അതിന്റെ മധ്യഭാഗത്തേക്ക് ഒരു പോയിന്റർ അല്ല (OOK ഒപ്പം സൂക്ഷിക്കുക
കോപ്പി-ഓൺ-റൈറ്റ്), കൂടാതെ "malloc" പോലെയുള്ള ഒരു നോൺ-ന്യൂഎക്സ് മെമ്മറി അലോക്കേറ്ററിൽ നിന്നായിരിക്കരുത്. ദി
സ്ട്രിംഗ് നീളം, "ലെൻ", നൽകണം. സ്ഥിരസ്ഥിതിയായി ഈ പ്രവർത്തനം "പുതുക്കുക" ചെയ്യും
(അതായത് realloc, move) മെമ്മറി "ptr" ചൂണ്ടിക്കാണിക്കുന്നു, അതിനാൽ ആ പോയിന്റർ പാടില്ല
sv_usepvn-ന് നൽകിയതിന് ശേഷം പ്രോഗ്രാമർ സ്വതന്ത്രമാക്കുകയോ ഉപയോഗിക്കുകയോ ചെയ്യുന്നു, രണ്ടും പാടില്ല
"പിന്നിൽ" നിന്നുള്ള ഏതെങ്കിലും പോയിന്ററുകൾ (ഉദാ ptr + 1) ഉപയോഗിക്കേണ്ടതാണ്.

"ഫ്ലാഗുകളും" SV_SMAGIC ഉം ശരിയാണെങ്കിൽ, SvSETMAGIC-നെ വിളിക്കും. "പതാകകൾ" എങ്കിൽ &
SV_HAS_TRAILING_NUL ശരിയാണ്, തുടർന്ന് "ptr[len]" "NUL" ആയിരിക്കണം, കൂടാതെ realloc ചെയ്യും
ഒഴിവാക്കണം (അതായത്, ബഫറിന് "ലെൻ" എന്നതിനേക്കാൾ 1 ബൈറ്റെങ്കിലും നീളമുണ്ട്, കൂടാതെ
"SvPVX"-ൽ സംഭരിക്കുന്നതിനുള്ള ആവശ്യകതകൾ ഇതിനകം നിറവേറ്റുന്നു).

void sv_usepvn_flags(SV *const sv, char* ptr,
കോൺസ്റ്റ് STRLEN ലെൻ,
const U32 പതാകകൾ)

sv_utf8_decode
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

എസ്‌വിയുടെ പിവി യു‌ടി‌എഫ്-8-ലെ ഒക്‌റ്ററ്റ് സീക്വൻസും ഒന്നിലധികം-ബൈറ്റ് അടങ്ങിയതും ആണെങ്കിൽ
പ്രതീകം, "SvUTF8" ഫ്ലാഗ് ഓണാക്കിയതിനാൽ അത് ഒരു പ്രതീകം പോലെ കാണപ്പെടുന്നു. എങ്കിൽ
പിവിയിൽ സിംഗിൾ-ബൈറ്റ് പ്രതീകങ്ങൾ മാത്രമേ അടങ്ങിയിട്ടുള്ളൂ, "SvUTF8" ഫ്ലാഗ് ഓഫാണ്. സ്കാൻ ചെയ്യുന്നു
സാധുതയ്ക്കുള്ള PV, PV അസാധുവായ UTF-8 ആണെങ്കിൽ തെറ്റായി നൽകുന്നു.

bool sv_utf8_decode(SV *const sv)

sv_utf8_downgrade
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

ഒരു എസ്‌വിയുടെ പിവിയെ പ്രതീകങ്ങളിൽ നിന്ന് ബൈറ്റുകളാക്കി മാറ്റാനുള്ള ശ്രമങ്ങൾ. പിവി അടങ്ങിയിട്ടുണ്ടെങ്കിൽ
ഒരു ബൈറ്റിൽ ഉൾക്കൊള്ളാൻ കഴിയാത്ത ഒരു പ്രതീകം, ഈ പരിവർത്തനം പരാജയപ്പെടും; ഈ സാഹചര്യത്തിൽ,
ഒന്നുകിൽ തെറ്റായി നൽകുന്നു അല്ലെങ്കിൽ "fail_ok" ശരിയല്ലെങ്കിൽ, ക്രോക്ക്സ്.

എൻകോഡിംഗ് ഇന്റർഫേസ് ബൈറ്റ് ചെയ്യാനുള്ള യൂണികോഡ് പൊതു ആവശ്യമല്ല: എൻകോഡ് ഉപയോഗിക്കുക
അതിനുള്ള വിപുലീകരണം.

bool sv_utf8_downgrade(SV *const sv,
const bool fail_ok)

sv_utf8_എൻകോഡ്
ഒരു SV-യുടെ PV UTF-8 ലേക്ക് പരിവർത്തനം ചെയ്യുന്നു, എന്നാൽ പിന്നീട് "SvUTF8" ഫ്ലാഗ് ഓഫ് ചെയ്യുന്നു.
വീണ്ടും ഒക്ടറ്റുകളായി കാണപ്പെടുന്നു.

അസാധുവായ sv_utf8_encode(SV *const sv)

sv_utf8_upgrade
ഒരു SV-യുടെ PV അതിന്റെ UTF-8-എൻകോഡ് ചെയ്ത ഫോമിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു. സ്ട്രിംഗ് ഫോമിലേക്ക് SV-യെ നിർബന്ധിക്കുന്നു
അത് ഇതിനകം ഇല്ലെങ്കിൽ. ഉചിതമെങ്കിൽ "sv"-ൽ "mg_get" ചെയ്യും. എപ്പോഴും സജ്ജമാക്കുന്നു
മുഴുവൻ സ്‌ട്രിംഗും ഒന്നുതന്നെയാണെങ്കിലും ഭാവിയിലെ സാധുത പരിശോധനകൾ ഒഴിവാക്കാൻ SvUTF8 ഫ്ലാഗ്
UTF-8 ൽ അല്ല. പരിവർത്തനം ചെയ്‌ത സ്‌ട്രിംഗിലെ ബൈറ്റുകളുടെ എണ്ണം നൽകുന്നു

ഇത് യൂണികോഡ് ഇന്റർഫേസിലേക്കുള്ള ഒരു പൊതു ഉദ്ദേശ്യ ബൈറ്റ് എൻകോഡിംഗ് അല്ല: എൻകോഡ് ഉപയോഗിക്കുക
അതിനുള്ള വിപുലീകരണം.

STRLEN sv_utf8_upgrade(SV *sv)

sv_utf8_upgrade_flags
ഒരു SV-യുടെ PV അതിന്റെ UTF-8-എൻകോഡ് ചെയ്ത ഫോമിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു. സ്ട്രിംഗ് ഫോമിലേക്ക് SV-യെ നിർബന്ധിക്കുന്നു
അത് ഇതിനകം ഇല്ലെങ്കിൽ. ഭാവിയിലെ സാധുതാ പരിശോധനകൾ ഒഴിവാക്കാൻ എപ്പോഴും SvUTF8 ഫ്ലാഗ് സജ്ജീകരിക്കുന്നു
UTF-8-ൽ എല്ലാ ബൈറ്റുകളും മാറ്റമില്ലാത്തതാണെങ്കിലും. "ഫ്ലാഗുകൾക്ക്" "SV_GMAGIC" ബിറ്റ് സെറ്റ് ഉണ്ടെങ്കിൽ,
ഉചിതമെങ്കിൽ "sv"-ൽ "mg_get" ചെയ്യും, അല്ലാത്തപക്ഷം.

"ഫ്ലാഗുകൾക്ക്" SV_FORCE_UTF8_UPGRADE സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, ഈ ഫംഗ്‌ഷൻ PV എന്ന് അനുമാനിക്കുന്നു
UTF-8-ലേക്ക് പരിവർത്തനം ചെയ്യുമ്പോൾ വികസിപ്പിക്കുക, അതിനായി പരിശോധിക്കുന്നതിനുള്ള അധിക ജോലി ഒഴിവാക്കുക.
സാധാരണയായി ഈ ഫ്ലാഗ് ഉപയോഗിക്കുന്നത് സ്ട്രിംഗ് ഇതിനകം പാഴ്‌സ് ചെയ്‌ത ഒരു ദിനചര്യയാണ്
അത്തരം പ്രതീകങ്ങൾ കണ്ടെത്തി, ജോലി ചെയ്യാതിരിക്കാൻ ഈ വിവരങ്ങൾ കൈമാറുന്നു
ആവർത്തിക്കേണ്ടതുണ്ട്.

പരിവർത്തനം ചെയ്‌ത സ്‌ട്രിംഗിലെ ബൈറ്റുകളുടെ എണ്ണം നൽകുന്നു.

ഇത് യൂണികോഡ് ഇന്റർഫേസിലേക്കുള്ള ഒരു പൊതു ഉദ്ദേശ്യ ബൈറ്റ് എൻകോഡിംഗ് അല്ല: എൻകോഡ് ഉപയോഗിക്കുക
അതിനുള്ള വിപുലീകരണം.

STRLEN sv_utf8_upgrade_flags(SV *const sv,
const I32 പതാകകൾ)

sv_utf8_upgrade_flags_grow
sv_utf8_upgrade_flags പോലെ, എന്നാൽ ഒരു അധിക പാരാമീറ്റർ "അധിക" ഉണ്ട്, അത്
ഉപയോഗിക്കാത്ത ബൈറ്റുകളുടെ എണ്ണം, 'sv' എന്ന സ്ട്രിംഗ് അതിന് ശേഷം സൗജന്യമായി ലഭിക്കുമെന്ന് ഉറപ്പുനൽകുന്നു
മടങ്ങുക. കോളർ പൂരിപ്പിക്കാൻ ഉദ്ദേശിക്കുന്ന അധിക സ്ഥലം റിസർവ് ചെയ്യാൻ ഇത് അനുവദിക്കുന്നു
അധിക വളർച്ച ഒഴിവാക്കുക.

"sv_utf8_upgrade", "sv_utf8_upgrade_nomg", "sv_utf8_upgrade_flags" എന്നിവയാണ്
ഈ പ്രവർത്തനത്തിന്റെ അടിസ്ഥാനത്തിൽ നടപ്പിലാക്കി.

പരിവർത്തനം ചെയ്‌ത സ്‌ട്രിംഗിലെ ബൈറ്റുകളുടെ എണ്ണം നൽകുന്നു (സ്‌പെയറുകൾ ഉൾപ്പെടുന്നില്ല).

STRLEN sv_utf8_upgrade_flags_grow(SV *const sv,
const I32 പതാകകൾ,
STRLEN അധിക)

sv_utf8_upgrade_nomg
sv_utf8_upgrade പോലെ, എന്നാൽ "sv"-ൽ മാജിക് ചെയ്യുന്നില്ല.

STRLEN sv_utf8_upgrade_nomg(SV *sv)

sv_catpvf
"vsprintf" പോലെയുള്ള അതിന്റെ ആർഗ്യുമെന്റുകൾ പ്രോസസ്സ് ചെയ്യുകയും ഫോർമാറ്റ് ചെയ്ത ഔട്ട്‌പുട്ട് ഒരു SV-യിലേക്ക് കൂട്ടിച്ചേർക്കുകയും ചെയ്യുന്നു.
'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നില്ല. "sv_catpvf_mg" കാണുക.

സാധാരണയായി അതിന്റെ മുൻഭാഗം "sv_catpvf" വഴിയാണ് ഉപയോഗിക്കുന്നത്.

അസാധുവായ sv_catpvf(എസ്വി * കോൺസ്റ്റ് എസ്വി, കോൺസ്റ്റ് ചാർ * കോൺസ്റ്റ് പാറ്റ്,
va_list *const args)

sv_catpvfn
void sv_catpvfn(SV *const sv, const char *const pat,
കോൺസ്റ്റ് STRLEN പാറ്റേൻ,
va_list *const args,
എസ്‌വി ** കോൺസ്റ്റ് സ്വർഗ്ഗുകൾ, കോൺസ്റ്റ് ഐ 32 എസ്വിമാക്‌സ്,
bool *const ഒരുപക്ഷെ_കളങ്കം)

sv_catpvfn_flags
"vsprintf" പോലെയുള്ള അതിന്റെ ആർഗ്യുമെന്റുകൾ പ്രോസസ്സ് ചെയ്യുകയും ഫോർമാറ്റ് ചെയ്ത ഔട്ട്‌പുട്ട് ഒരു SV-യിലേക്ക് കൂട്ടിച്ചേർക്കുകയും ചെയ്യുന്നു.
സി സ്റ്റൈൽ വേരിയബിൾ ആർഗ്യുമെന്റ് ലിസ്റ്റ് (NULL) നഷ്‌ടപ്പെട്ടാൽ SV-കളുടെ ഒരു ശ്രേണി ഉപയോഗിക്കുന്നു.
ടെയ്‌ന്റ് ചെക്കുകൾ പ്രവർത്തനക്ഷമമാക്കി പ്രവർത്തിക്കുമ്പോൾ, ഫലമുണ്ടെങ്കിൽ "maybe_tainted" വഴി സൂചിപ്പിക്കുന്നു
അവിശ്വസനീയമാണ് (പലപ്പോഴും പ്രദേശങ്ങളുടെ ഉപയോഗം കാരണം).

"sv_catpvfn" എന്ന് വിളിക്കുകയോ ഫ്ലാഗുകളിൽ "SV_GMAGIC" ഉൾപ്പെടുകയോ ചെയ്താൽ, കോളുകൾക്ക് മാന്ത്രികത ലഭിക്കും.

സാധാരണയായി അതിന്റെ മുൻഭാഗങ്ങളിലൊന്നായ "sv_catpvf", "sv_vcatpvf_mg" എന്നിവ വഴിയാണ് ഉപയോഗിക്കുന്നത്.

അസാധുവായ sv_catpvfn_flags(SV *const sv,
കോൺസ്റ്റ് ചാർ * കോൺസ്റ്റ് പാറ്റ്,
കോൺസ്റ്റ് STRLEN പാറ്റേൻ,
va_list *const args,
എസ്.വി ** കോൺസ്റ്റ് svargs,
const I32 svmax,
bool *const ഒരുപക്ഷെ_കളങ്കം,
const U32 പതാകകൾ)

sv_catpvf_mg
"sv_catpvf" പോലെ, മാത്രമല്ല 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു.

സാധാരണയായി അതിന്റെ മുൻഭാഗം "sv_catpvf_mg" വഴിയാണ് ഉപയോഗിക്കുന്നത്.

അസാധുവായ sv_catpvf_mg(SV *const sv,
കോൺസ്റ്റ് ചാർ * കോൺസ്റ്റ് പാറ്റ്,
va_list *const args)

sv_setpvf
"sv_catpvf" പോലെ പ്രവർത്തിക്കുന്നു, എന്നാൽ ടെക്‌സ്‌റ്റ് കൂട്ടിച്ചേർക്കുന്നതിന് പകരം SV-യിലേക്ക് പകർത്തുന്നു.
'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നില്ല. "sv_setpvf_mg" കാണുക.

സാധാരണയായി അതിന്റെ മുൻഭാഗം "sv_setpvf" വഴിയാണ് ഉപയോഗിക്കുന്നത്.

void sv_setpvf(SV *const sv, const char *const pat,
va_list *const args)

sv_setpvfn
"sv_catpvfn" പോലെ പ്രവർത്തിക്കുന്നു, പക്ഷേ ടെക്‌സ്‌റ്റ് കൂട്ടിച്ചേർക്കുന്നതിന് പകരം SV-യിലേക്ക് പകർത്തുന്നു.

സാധാരണയായി അതിന്റെ മുൻഭാഗങ്ങളിലൊന്നായ "sv_vsetpvf", "sv_vsetpvf_mg" എന്നിവ വഴിയാണ് ഉപയോഗിക്കുന്നത്.

void sv_setpvfn(SV *const sv, const char *const pat,
കോൺസ്റ്റ് STRLEN പാറ്റേൻ,
va_list *const args,
എസ്‌വി ** കോൺസ്റ്റ് സ്വർഗ്ഗുകൾ, കോൺസ്റ്റ് ഐ 32 എസ്വിമാക്‌സ്,
bool *const ഒരുപക്ഷെ_കളങ്കം)

sv_setpvf_mg
"sv_setpvf" പോലെ, മാത്രമല്ല 'സെറ്റ്' മാജിക് കൈകാര്യം ചെയ്യുന്നു.

സാധാരണയായി അതിന്റെ മുൻഭാഗം "sv_setpvf_mg" വഴിയാണ് ഉപയോഗിക്കുന്നത്.

അസാധുവായ sv_setpvf_mg(SV *const sv,
കോൺസ്റ്റ് ചാർ * കോൺസ്റ്റ് പാറ്റ്,
va_list *const args)

യൂണിക്കോഡ് പിന്തുണ

perlguts-ലെ "യൂണികോഡ് പിന്തുണ" ഈ API-യ്ക്ക് ഒരു ആമുഖമുണ്ട്.

"പ്രതീക വർഗ്ഗീകരണം", "കഥാപാത്രം മാറൽ" എന്നിവയും കാണുക. വിവിധ പ്രവർത്തനങ്ങൾ
ഈ വിഭാഗത്തിന് പുറത്ത് പ്രത്യേകമായി യൂണികോഡിനൊപ്പം പ്രവർത്തിക്കുന്നു. "utf8" എന്ന സ്ട്രിംഗിനായി തിരയുക
ഈ പ്രമാണം.

bytes_cmp_utf8
"b", "blen" എന്നിവയിലെ പ്രതീകങ്ങളുടെ (ഒക്ടറ്റുകളായി സംഭരിച്ചിരിക്കുന്ന) ക്രമം താരതമ്യം ചെയ്യുന്നു
"u", "ulen" എന്നിവയിലെ പ്രതീകങ്ങളുടെ ക്രമം (UTF-8 ആയി സംഭരിച്ചിരിക്കുന്നു). അവയാണെങ്കിൽ 0 നൽകുന്നു
തുല്യം, -1 അല്ലെങ്കിൽ -2, ആദ്യ സ്‌ട്രിങ്ങ് രണ്ടാമത്തെ സ്‌ട്രിങ്ങിനേക്കാൾ കുറവാണെങ്കിൽ, +1 അല്ലെങ്കിൽ +2 എങ്കിൽ
ആദ്യത്തെ ചരട് രണ്ടാമത്തെ സ്ട്രിംഗിനെക്കാൾ വലുതാണ്.

-1 അല്ലെങ്കിൽ +1 എന്നതിന്റെ ചെറിയ സ്‌ട്രിംഗിന്റെ ആരംഭത്തിന് സമാനമാണെങ്കിൽ തിരികെ നൽകും
നീളമുള്ള ചരട്. പ്രതീകങ്ങൾ തമ്മിൽ വ്യത്യാസമുണ്ടെങ്കിൽ -2 അല്ലെങ്കിൽ +2 തിരികെ നൽകും
ചരടുകൾക്കുള്ളിൽ.

int bytes_cmp_utf8(const U8 *b, STRLEN ബ്ലെൻ,
const U8 *u, STRLEN ulen)

bytes_from_utf8
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

UTF-8-ൽ നിന്ന് "ലെൻ" നീളമുള്ള "s" സ്ട്രിംഗ് നേറ്റീവ് ബൈറ്റ് എൻകോഡിംഗിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു.
"utf8_to_bytes" പോലെയല്ല, "bytes_to_utf8" പോലെ, പുതുതായി ഒരു പോയിന്റർ നൽകുന്നു-
സ്ട്രിംഗ് സൃഷ്ടിച്ചു, പുതിയ ദൈർഘ്യം ഉൾക്കൊള്ളാൻ "len" അപ്ഡേറ്റ് ചെയ്യുന്നു. ഒറിജിനൽ തിരികെ നൽകുന്നു
പരിവർത്തനം സംഭവിക്കുന്നില്ലെങ്കിൽ, "len" മാറ്റമില്ല. "is_utf8" ആണെങ്കിൽ ഒന്നും ചെയ്യരുത്
പോയിന്റ് 0. "s" പരിവർത്തനം ചെയ്യപ്പെടുകയോ പൂർണ്ണമായി ഉൾക്കൊള്ളുകയോ ചെയ്താൽ "is_utf8" 0 ആയി സജ്ജമാക്കുന്നു
utf8-ൽ മാറ്റമില്ലാത്ത പ്രതീകങ്ങൾ (അതായത്, EBCDIC ഇതര മെഷീനുകളിൽ US-ASCII).

U8* bytes_from_utf8(const U8 *s, STRLEN *len,
bool *is_utf8)

bytes_to_utf8
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

നേറ്റീവ് എൻകോഡിംഗിൽ നിന്ന് UTF-8 ലേക്ക് നീളമുള്ള "ലെൻ" ബൈറ്റുകളുടെ "s" സ്ട്രിംഗ് പരിവർത്തനം ചെയ്യുന്നു.
പുതുതായി സൃഷ്‌ടിച്ച സ്‌ട്രിംഗിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു, പുതിയത് പ്രതിഫലിപ്പിക്കുന്നതിന് "len" സജ്ജമാക്കുന്നു
നീളം ബൈറ്റുകളിൽ.

സ്ട്രിംഗിന്റെ അവസാനത്തിന് ശേഷം ഒരു "NUL" പ്രതീകം എഴുതപ്പെടും.

നേറ്റീവ് (ലാറ്റിൻ8 അല്ലെങ്കിൽ
EBCDIC), "sv_recode_to_utf8"() കാണുക.

U8* bytes_to_utf8(const U8 *s, STRLEN *len)

DO_UTF8 "sv" എന്നതിലെ PV ആയി കണക്കാക്കണോ വേണ്ടയോ എന്ന് നൽകുന്ന ഒരു ബൂൾ നൽകുന്നു
UTF-8-ൽ എൻകോഡ് ചെയ്‌തിരിക്കുന്നു.

നിങ്ങൾ ഇത് ഉപയോഗിക്കണം ശേഷം "SvPV()" എന്നതിലേക്കോ അതിന്റെ വകഭേദങ്ങളിൽ ഒന്നിലേക്കോ ഒരു കോൾ, എന്തെങ്കിലും ഉണ്ടെങ്കിൽ
കോൾ ടു സ്ട്രിംഗ് ഓവർലോഡിംഗ് ആന്തരിക UTF-8 എൻകോഡിംഗ് ഫ്ലാഗ് അപ്ഡേറ്റ് ചെയ്യുന്നു.

bool DO_UTF8(SV* sv)

foldEQ_utf8
"s1", "s2" എന്നീ സ്ട്രിംഗുകളുടെ മുൻനിര ഭാഗങ്ങൾ (ഒന്നുകിൽ അല്ലെങ്കിൽ രണ്ടും) ആണെങ്കിൽ ശരി നൽകുന്നു
അവയിൽ UTF-8-ൽ ആയിരിക്കാം) സമാന സംവേദനക്ഷമതയില്ലാത്തവയാണ്; അല്ലാത്തപക്ഷം തെറ്റ്. എങ്ങനെ
താരതമ്യം ചെയ്യാനുള്ള സ്ട്രിംഗുകളിലേക്ക് മറ്റ് ഇൻപുട്ട് പാരാമീറ്ററുകൾ നിർണ്ണയിക്കുന്നു.

"u1" ശരിയാണെങ്കിൽ, "s1" സ്ട്രിംഗ് UTF-8-എൻകോഡ് ചെയ്ത യൂണികോഡിലാണെന്ന് അനുമാനിക്കപ്പെടുന്നു;
അല്ലെങ്കിൽ ഇത് നേറ്റീവ് 8-ബിറ്റ് എൻകോഡിംഗിലാണെന്ന് അനുമാനിക്കപ്പെടുന്നു. അതിനനുസരിച്ച് "u2"
"s2" നെ സംബന്ധിച്ച്.

ബൈറ്റ് ദൈർഘ്യം "l1" പൂജ്യമല്ലെങ്കിൽ, അത് "s1" ലേക്ക് എത്ര ദൂരം ഫോൾഡ് പരിശോധിക്കണമെന്ന് പറയുന്നു
സമത്വം. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, എത്തിച്ചേരാനുള്ള ലക്ഷ്യമായി "s1"+"l1" ഉപയോഗിക്കും. സ്കാൻ
ലക്ഷ്യത്തിലെത്തുകയും സ്കാൻ ചെയ്യുകയും ചെയ്യുന്നില്ലെങ്കിൽ ഒരു മത്സരമായി കണക്കാക്കില്ല
ആ ലക്ഷ്യത്തെ മറികടക്കാൻ പോകുന്നില്ല. "s2" എന്നതുമായി ബന്ധപ്പെട്ട് "l2" എന്നതിന്.

"pe1" NULL അല്ലാത്തതും അത് ചൂണ്ടിക്കാണിക്കുന്ന പോയിന്റർ NULL അല്ലാത്തതും ആണെങ്കിൽ, ആ പോയിന്റർ
"s1" ലെ പരമാവധി പോയിന്റ് കഴിഞ്ഞുള്ള 1 ബൈറ്റ് സ്ഥാനത്തേക്കുള്ള അവസാന പോയിന്ററായി കണക്കാക്കുന്നു
അതിനപ്പുറം ഒരു സാഹചര്യത്തിലും സ്കാനിംഗ് തുടരില്ല. (ഈ പതിവ്
UTF-8 എൻകോഡ് ചെയ്ത ഇൻപുട്ട് സ്ട്രിംഗുകൾ തെറ്റായി രൂപപ്പെടുത്തിയിട്ടില്ലെന്ന് അനുമാനിക്കുന്നു; തെറ്റായ ഇൻപുട്ട് കഴിയും
അത് "pe1" കഴിഞ്ഞതായി വായിക്കാൻ കാരണമാകുന്നു). ഇതിനർത്ഥം "l1" ഉം "pe1" ഉം ആണെങ്കിൽ എന്നാണ്
വ്യക്തമാക്കിയിട്ടുണ്ട്, കൂടാതെ "pe1" എന്നത് "s1"+"l1" നേക്കാൾ കുറവാണ്, മത്സരം ഒരിക്കലും വിജയിക്കില്ല
കാരണം അതിന് ഒരിക്കലും അതിന്റെ ലക്ഷ്യത്തിലേക്കെത്താൻ കഴിയില്ല (വാസ്തവത്തിൽ എതിർക്കുന്നു).
"s2" എന്നതുമായി ബന്ധപ്പെട്ട് "pe2" എന്നതിന്.

"s1", "s2" എന്നിവയിൽ ഒരെണ്ണമെങ്കിലും ലക്ഷ്യമുണ്ടായിരിക്കണം (കുറഞ്ഞത് "l1", "l2" എന്നിവയിലൊന്നെങ്കിലും ഉണ്ടായിരിക്കണം.
പൂജ്യമല്ല), രണ്ടും അങ്ങനെ ചെയ്യുകയാണെങ്കിൽ, വിജയകരമായ ഒരു പൊരുത്തത്തിനായി ഇരുവരും എത്തിച്ചേരേണ്ടതുണ്ട്.
കൂടാതെ, ഒരു പ്രതീകത്തിന്റെ ഫോൾഡ് ഒന്നിലധികം പ്രതീകങ്ങളാണെങ്കിൽ, അവയെല്ലാം ആയിരിക്കണം
പൊരുത്തപ്പെട്ടു ('മടക്കുന്നതിന്' താഴെയുള്ള tr21 റഫറൻസ് കാണുക).

വിജയകരമായ ഒരു പൊരുത്തത്തിന് ശേഷം, "pe1" NULL അല്ലാത്തതാണെങ്കിൽ, അത് പോയിന്റ് ആയി സജ്ജീകരിക്കും
ന്റെ ആരംഭം തൊട്ടടുത്ത പൊരുത്തപ്പെടുത്തുന്നതിന് അപ്പുറം "s1" എന്ന പ്രതീകം. അതിനനുസൃതമായി
"pe2", "s2" എന്നിവയ്ക്കായി.

കേസ്-ഇൻസെൻസിറ്റിവിറ്റിക്ക്, പകരം യൂണിക്കോഡിന്റെ "കേസ്ഫോൾഡിംഗ്" ഉപയോഗിക്കുന്നു
രണ്ട് അക്ഷരങ്ങളും മുകളിൽ/ചെറിയ അക്ഷരങ്ങൾ, കാണുക
<http://www.unicode.org/unicode/reports/tr21/> (കേസ് മാപ്പിംഗ്സ്).

I32 foldEQ_utf8(const char *s1, char **pe1, UV l1,
bool u1, const char *s2, char **pe2,
UV l2, bool u2)

UTF8_CHAR ആണ്
നിയമപരമായ UTF-8 (അല്ലെങ്കിൽ UTF-) രൂപീകരിക്കുന്ന "s" ൽ ആരംഭിക്കുന്ന ബൈറ്റുകളുടെ എണ്ണം നൽകുന്നു.
EBCDIC) എൻകോഡ് ചെയ്‌ത പ്രതീകം, "e - s" ബൈറ്റുകൾ "s" എന്നതിലേക്ക് നോക്കുന്നില്ല.
"s" മുതൽ "e - 0" വരെയുള്ള ക്രമം UTF-1 നന്നായി രൂപപ്പെടുത്തിയില്ലെങ്കിൽ 8 നൽകുന്നു

ഒരു മാറ്റമില്ലാത്ത പ്രതീകം (അതായത് EBCDIC ഇതര മെഷീനുകളിൽ ASCII) സാധുതയുള്ളതാണെന്ന് ശ്രദ്ധിക്കുക
UTF-8 പ്രതീകം.

STRLEN isUTF8_CHAR(const U8 *s, const U8 *e)

is_ascii_string
"is_invariant_string" എന്നതിന്റെ തെറ്റിദ്ധരിപ്പിക്കുന്ന പേരിലുള്ള പര്യായപദമാണിത്. ASCII-ഇഷിൽ
പ്ലാറ്റ്‌ഫോമുകളിൽ, പേര് തെറ്റിദ്ധരിപ്പിക്കുന്നതല്ല: ASCII-ശ്രേണിയിലുള്ള പ്രതീകങ്ങൾ കൃത്യമായി
UTF-8 മാറ്റമില്ലാത്തവ. എന്നാൽ EBCDIC മെഷീനുകൾക്ക് ASCII-യെക്കാൾ കൂടുതൽ മാറ്റങ്ങളുണ്ട്
പ്രതീകങ്ങൾ, അതിനാൽ "is_invariant_string" ആണ് തിരഞ്ഞെടുക്കുന്നത്.

bool is_ascii_string(const U8 *s, STRLEN ലെൻ)

മാറ്റമില്ലാത്ത_സ്ട്രിംഗ്
"s" എന്ന സ്ട്രിംഗിന്റെ ആദ്യ "ലെൻ" ബൈറ്റുകൾ പരിഗണിക്കാതെ തന്നെ ഒരുപോലെയാണെങ്കിൽ ശരിയാണെന്ന് നൽകുന്നു
സ്ട്രിംഗിന്റെ UTF-8 എൻകോഡിംഗിന്റെ (അല്ലെങ്കിൽ EBCDIC മെഷീനുകളിലെ UTF-EBCDIC എൻകോഡിംഗ്).
അതായത്, അവ UTF-8 മാറ്റമില്ലാത്തവയാണെങ്കിൽ. ASCII-ish മെഷീനുകളിൽ, എല്ലാ ASCII
പ്രതീകങ്ങളും ASCII പ്രതീകങ്ങളും മാത്രമേ ഈ നിർവചനത്തിന് അനുയോജ്യമാകൂ. EBCDIC മെഷീനുകളിൽ,
ASCII-റേഞ്ച് പ്രതീകങ്ങൾ മാറ്റമില്ലാത്തവയാണ്, എന്നാൽ C1 നിയന്ത്രണങ്ങളും
"\c?" (ഇബിസിഡിഐസിയിലെ ASCII ശ്രേണിയിൽ ഇല്ല).

"len" 0 ആണെങ്കിൽ, അത് strlen(s) ഉപയോഗിച്ച് കണക്കാക്കും (അതായത് നിങ്ങൾ ഇത് ഉപയോഗിക്കുകയാണെങ്കിൽ
ഓപ്ഷൻ, "s" ന് "NUL" പ്രതീകങ്ങൾ ഉൾച്ചേർക്കാനാവില്ല, കൂടാതെ a ഉണ്ടായിരിക്കണം
"NUL" ബൈറ്റ് അവസാനിപ്പിക്കുന്നു).

"is_utf8_string"(), "is_utf8_string_loclen"(), കൂടാതെ എന്നിവയും കാണുക
"is_utf8_string_loc"().

bool is_invariant_string(const U8 *s, STRLEN ലെൻ)

is_utf8_string
"s" സ്‌ട്രിംഗിന്റെ ആദ്യ "ലെൻ" ബൈറ്റുകൾ സാധുവായ UTF-8 സ്ട്രിംഗ് രൂപപ്പെടുത്തിയാൽ ശരിയാണെന്ന് നൽകുന്നു,
അല്ലാത്തപക്ഷം തെറ്റ്. "len" 0 ആണെങ്കിൽ, അത് strlen(s) ഉപയോഗിച്ച് കണക്കാക്കും (ഏത്
നിങ്ങൾ ഈ ഓപ്‌ഷൻ ഉപയോഗിക്കുകയാണെങ്കിൽ, "s" ന് "NUL" പ്രതീകങ്ങൾ ഉൾച്ചേർക്കാൻ കഴിയില്ല
അവസാനിപ്പിക്കുന്ന "NUL" ബൈറ്റ് ഉണ്ടായിരിക്കണം). എല്ലാ പ്രതീകങ്ങളും ASCII ആണെന്നത് ശ്രദ്ധിക്കുക
'ഒരു സാധുവായ UTF-8 സ്ട്രിംഗ്' ഉണ്ടാക്കുക.

"is_invariant_string"(), "is_utf8_string_loclen"(), കൂടാതെ എന്നിവയും കാണുക
"is_utf8_string_loc"().

bool is_utf8_string(const U8 *s, STRLEN ലെൻ)

is_utf8_string_loc
"is_utf8_string" പോലെ എന്നാൽ പരാജയത്തിന്റെ സ്ഥാനം സംഭരിക്കുന്നു (ഇതിന്റെ കാര്യത്തിൽ
"utf8ness പരാജയം") അല്ലെങ്കിൽ ലൊക്കേഷൻ "s"+"len" ("utf8ness success" ന്റെ കാര്യത്തിൽ)
"ep" ൽ.

"is_utf8_string_loclen"(), "is_utf8_string"() എന്നിവയും കാണുക.

bool is_utf8_string_loc(const U8 *s, STRLEN ലെൻ,
const U8 **ep)

is_utf8_string_loclen
"is_utf8_string"() പോലെ എന്നാൽ പരാജയത്തിന്റെ സ്ഥാനം സംഭരിക്കുന്നു (ഇതിന്റെ കാര്യത്തിൽ
"utf8ness പരാജയം") അല്ലെങ്കിൽ ലൊക്കേഷൻ "s"+"len" ("utf8ness success" ന്റെ കാര്യത്തിൽ)
"ep" ൽ, കൂടാതെ "el" ലെ UTF-8 എൻകോഡ് ചെയ്ത പ്രതീകങ്ങളുടെ എണ്ണം.

"is_utf8_string_loc"(), "is_utf8_string"() എന്നിവയും കാണുക.

bool is_utf8_string_loclen(const U8 *s, STRLEN ലെൻ,
const U8 **ep, STRLEN *el)

pv_uni_display
"spv", ദൈർഘ്യം "len" എന്ന സ്ട്രിംഗിന്റെ പ്രദർശനയോഗ്യമായ പതിപ്പ് "dsv" എന്ന സ്കെയിലറിലേക്ക് നിർമ്മിക്കുക,
പ്രദർശിപ്പിക്കാവുന്ന പതിപ്പ് പരമാവധി "pvlim" ബൈറ്റുകൾ നീളമുള്ളതാണ് (ദൈർഘ്യമേറിയതാണെങ്കിൽ, ബാക്കിയുള്ളത്
വെട്ടിച്ചുരുക്കി "..." കൂട്ടിച്ചേർക്കും).

"ഫ്ലാഗുകൾ" ആർഗ്യുമെന്റിന് UNI_DISPLAY_ISPRINT പ്രദർശിപ്പിക്കാൻ സജ്ജമാക്കാം isPRINT()കഴിവുള്ളവൻ
പ്രതീകങ്ങൾ സ്വയം, \\[nrfta\\] പ്രദർശിപ്പിക്കുന്നതിന് UNI_DISPLAY_BACKSLASH
ബാക്ക്‌സ്ലാഷ് ചെയ്ത പതിപ്പുകൾ ('\n' പോലെ) (UNI_DISPLAY_BACKSLASH ആണ് മുൻഗണന
\\) എന്നതിനായുള്ള UNI_DISPLAY_ISPRINT. UNI_DISPLAY_QQ (അതിന്റെ അപരനാമവും UNI_DISPLAY_REGEX)
UNI_DISPLAY_BACKSLASH ഉം UNI_DISPLAY_ISPRINT ഉം ഓണാക്കിയിരിക്കുന്നു.

"dsv" യുടെ PV-യിലേക്കുള്ള പോയിന്റർ തിരികെ നൽകുന്നു.

"sv_uni_display" എന്നതും കാണുക.

char* pv_uni_display(SV *dsv, const U8 *spv,
STRLEN ലെൻ, STRLEN pvlim,
യുവി പതാകകൾ)

sv_cat_decode
എൻകോഡിംഗ് ഒരു എൻകോഡ് ഒബ്ജക്റ്റ് ആണെന്ന് അനുമാനിക്കപ്പെടുന്നു, ssv യുടെ PV എന്ന് അനുമാനിക്കപ്പെടുന്നു
എൻകോഡിംഗിലും ഡീകോഡിംഗിലുമുള്ള ഒക്ടറ്റുകൾ ഇൻപുട്ട് ആരംഭിക്കുന്നത് ഏത് സ്ഥാനത്തു നിന്നാണ് (പിവി
+ *ഓഫ്സെറ്റ്) ചൂണ്ടിക്കാട്ടി. ഡീകോഡ് ചെയ്‌ത UTF-8 സ്‌ട്രിംഗിൽ നിന്ന് dsv സംയോജിപ്പിക്കും
ssv ഡീകോഡിംഗ് ഔട്ട്പുട്ടിൽ അല്ലെങ്കിൽ സ്ട്രിംഗ് tstr ദൃശ്യമാകുമ്പോൾ ഡീകോഡിംഗ് അവസാനിക്കും
ഇൻപുട്ട് ssv-യുടെ PV-യിൽ അവസാനിക്കുന്നു. ഓഫ്‌സെറ്റ് പോയിന്റുകൾ ആയിരിക്കുന്ന മൂല്യം
ssv-യിലെ അവസാന ഇൻപുട്ട് സ്ഥാനത്തേക്ക് പരിഷ്‌ക്കരിച്ചു.

ടെർമിനേറ്റർ കണ്ടെത്തിയാൽ TRUE നൽകുന്നു, അല്ലെങ്കിൽ FALSE നൽകുന്നു.

bool sv_cat_decode(SV* dsv, SV *എൻകോഡിംഗ്, SV *ssv,
int *ഓഫ്‌സെറ്റ്, char* tstr, int tlen)

sv_recode_to_utf8
എൻകോഡിംഗ് ഒരു എൻകോഡ് ഒബ്ജക്റ്റ് ആണെന്ന് അനുമാനിക്കപ്പെടുന്നു, പ്രവേശിക്കുമ്പോൾ sv യുടെ PV ആണ്
ആ എൻകോഡിംഗിൽ ഒക്ടറ്റുകളാണെന്ന് അനുമാനിക്കപ്പെടുന്നു, കൂടാതെ sv യൂണികോഡിലേക്ക് പരിവർത്തനം ചെയ്യപ്പെടും
(ഒപ്പം UTF-8).

sv ഇതിനകം UTF-8 ആണെങ്കിൽ (അല്ലെങ്കിൽ അത് POK അല്ലെങ്കിൽ), അല്ലെങ്കിൽ എൻകോഡിംഗ് ഒരു
റഫറൻസ്, എസ്.വി.യിൽ ഒന്നും ചെയ്തിട്ടില്ല. എൻകോഡിംഗ് ഒരു "എൻകോഡ്::XS" അല്ലെങ്കിൽ
എൻകോഡിംഗ് ഒബ്ജക്റ്റ്, മോശമായ കാര്യങ്ങൾ സംഭവിക്കും. (കാണുക lib/encoding.pm കൂടാതെ എൻകോഡ് ചെയ്യുക.)

sv യുടെ PV തിരികെ ലഭിച്ചു.

char* sv_recode_to_utf8(SV* sv, SV *എൻകോഡിംഗ്)

sv_uni_display
"dsv" എന്ന സ്കെയിലറിലേക്ക് "sv" എന്ന സ്കെയിലറിന്റെ പ്രദർശിപ്പിക്കാവുന്ന പതിപ്പ് നിർമ്മിക്കുക, the
പ്രദർശിപ്പിക്കാവുന്ന പതിപ്പ് പരമാവധി "pvlim" ബൈറ്റുകൾ നീളമുള്ളതാണ് (ദൈർഘ്യമേറിയതാണെങ്കിൽ, ബാക്കിയുള്ളത്
വെട്ടിച്ചുരുക്കി "..." കൂട്ടിച്ചേർക്കും).

"ഫ്ലാഗ്സ്" ആർഗ്യുമെന്റ് "pv_uni_display"() പോലെയാണ്.

"dsv" യുടെ PV-യിലേക്കുള്ള പോയിന്റർ തിരികെ നൽകുന്നു.

char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim,
യുവി പതാകകൾ)

to_utf8_case
"p" എന്നതിൽ UTF-8 സ്ട്രിംഗിലേക്കുള്ള പോയിന്റർ അടങ്ങിയിരിക്കുന്നു, അത് പ്രതീകം എൻകോഡ് ചെയ്യുന്നു
പരിവർത്തനം ചെയ്തു. "p" എന്നതിലെ കഥാപാത്രം നന്നായി രൂപപ്പെടുത്തിയതാണെന്ന് ഈ പതിവ് അനുമാനിക്കുന്നു.

പരിവർത്തന ഫലം നൽകുന്നതിനുള്ള പ്രതീക ബഫറിലേക്കുള്ള ഒരു പോയിന്ററാണ് "ustrp".
ഫലത്തിന്റെ ദൈർഘ്യത്തിലേക്കുള്ള ഒരു പോയിന്ററാണ് "lenp".

"swashp" എന്നത് ഉപയോഗിക്കാനുള്ള swash-ലേക്കുള്ള ഒരു പോയിന്ററാണ്.

പ്രത്യേകവും സാധാരണവുമായ മാപ്പിംഗുകൾ സംഭരിച്ചിരിക്കുന്നു lib/unicore/To/Foo.pl, ഒപ്പം
SWASHNEW, ഉപയോഗിച്ച് ലോഡ് ചെയ്തത് lib/utf8_heavy.pl. "പ്രത്യേക" (സാധാരണയായി, എന്നാൽ എല്ലായ്പ്പോഴും അല്ല,
ഒരു മൾട്ടി ക്യാരക്ടർ മാപ്പിംഗ്), ആദ്യം പരീക്ഷിച്ചു.

"special" എന്നത് ഒരു സ്ട്രിംഗ് ആണ്, സാധാരണയായി "NULL" അല്ലെങ്കിൽ "". "NULL" എന്നാൽ പ്രത്യേകമായൊന്നും ഉപയോഗിക്കാതിരിക്കുക എന്നാണ്
മാപ്പിംഗുകൾ; "" എന്നാൽ പ്രത്യേക മാപ്പിംഗുകൾ ഉപയോഗിക്കുക എന്നാണ്. ഇവ രണ്ടും ഒഴികെയുള്ള മൂല്യങ്ങൾ
പോലുള്ള പ്രത്യേക മാപ്പിംഗുകൾ അടങ്ങിയ ഹാഷിന്റെ പേരായി കണക്കാക്കുന്നു
"utf8::ToSpecLower".

"Normal" എന്നത് "ToLower" പോലെയുള്ള ഒരു സ്ട്രിംഗ് ആണ്, അതായത് swash %utf8::ToLower.

UV to_utf8_case(const U8 *p, U8* ustrp,
STRLEN *lenp, SV **swashp,
കോൺസ്റ്റ് ചാർ *സാധാരണ,
കോൺസ്റ്റ് ചാർ *സ്പെഷ്യൽ)

to_utf8_fold
പകരം "toFOLD_utf8" ഉപയോഗിക്കുക.

UV to_utf8_fold(const U8 *p, U8* ustrp,
STRLEN *lenp)

to_utf8_lower
പകരം "toLOWER_utf8" ഉപയോഗിക്കുക.

UV to_utf8_lower(const U8 *p, U8* ustrp,
STRLEN *lenp)

to_utf8_title
പകരം "toTITLE_utf8" ഉപയോഗിക്കുക.

UV to_utf8_title(const U8 *p, U8* ustrp,
STRLEN *lenp)

to_utf8_upper
പകരം "toUPPER_utf8" ഉപയോഗിക്കുക.

UV to_utf8_upper(const U8 *p, U8* ustrp,
STRLEN *lenp)

utf8n_to_uvchr
ഈ ഫംഗ്ഷൻ വളരെ പ്രത്യേകമായ സാഹചര്യങ്ങളിൽ മാത്രമേ ഉപയോഗിക്കാവൂ. മിക്ക കോഡ്
ഇത് നേരിട്ട് വിളിക്കുന്നതിന് പകരം "utf8_to_uvchr_buf"() ഉപയോഗിക്കണം.

താഴത്തെ നില UTF-8 ഡീകോഡ് ദിനചര്യ. എന്നതിന്റെ നേറ്റീവ് കോഡ് പോയിന്റ് മൂല്യം നൽകുന്നു
UTF-8-ൽ (അല്ലെങ്കിൽ UTF-EBCDIC) ആയിരിക്കുമെന്ന് അനുമാനിക്കപ്പെടുന്ന "s" എന്ന സ്ട്രിംഗിലെ ആദ്യ പ്രതീകം
എൻകോഡിംഗ്, കൂടാതെ "ചുരുണ്ട" ബൈറ്റുകളേക്കാൾ ദൈർഘ്യമേറിയതല്ല; *retlen ("retlen" NULL അല്ലെങ്കിൽ) ചെയ്യും
ആ പ്രതീകത്തിന്റെ നീളം, ബൈറ്റുകളിൽ സജ്ജമാക്കുക.

"പതാകകളുടെ" മൂല്യം "കൾ" ഒരു കിണറിലേക്ക് വിരൽ ചൂണ്ടാത്തപ്പോൾ പെരുമാറ്റം നിർണ്ണയിക്കുന്നു-
UTF-8 പ്രതീകം രൂപീകരിച്ചു. "പതാകകൾ" 0 ആണെങ്കിൽ, ഒരു അപാകത കണ്ടെത്തുമ്പോൾ, പൂജ്യം
റിട്ടേൺ ചെയ്‌ത് *retlen സജ്ജീകരിച്ചതിനാൽ ("s" + *retlen) ആണ് അടുത്ത സാധ്യമായ സ്ഥാനം
"s"-ൽ, അത് വികലമല്ലാത്ത ഒരു പ്രതീകം ആരംഭിക്കാം. കൂടാതെ, UTF-8 മുന്നറിയിപ്പുകൾ ആണെങ്കിൽ
ലെക്സിക്കലി അപ്രാപ്തമാക്കിയിട്ടില്ല, ഒരു മുന്നറിയിപ്പ് ഉയർന്നു.

"ഫ്ലാഗുകളിൽ" വിവിധ ALLOW ഫ്ലാഗുകൾ സജ്ജീകരിക്കാൻ കഴിയും (അല്ലെങ്കിൽ മുന്നറിയിപ്പ് നൽകരുത്).
ക്രമം നീണ്ടുനിൽക്കുന്നത് പോലുള്ള തകരാറുകളുടെ തരങ്ങൾ (അതായത്, അവിടെ എപ്പോൾ
ഒരേ കോഡ് പോയിന്റ് പ്രകടിപ്പിക്കാൻ കഴിയുന്ന ഒരു ചെറിയ ശ്രേണിയാണ്; ഓവർലോംഗ് സീക്വൻസുകളാണ്
സാധ്യതയുള്ള സുരക്ഷാ പ്രശ്നങ്ങൾ കാരണം UTF-8 സ്റ്റാൻഡേർഡിൽ വ്യക്തമായി നിരോധിച്ചിരിക്കുന്നു).
മറ്റൊരു വികലമായ ഉദാഹരണം ഒരു കഥാപാത്രത്തിന്റെ ആദ്യ ബൈറ്റ് നിയമപരമല്ല
ആദ്യ ബൈറ്റ്. കാണുക utf8.h അത്തരം പതാകകളുടെ പട്ടികയ്ക്കായി. അനുവദനീയമായ 0 നീളമുള്ള സ്ട്രിംഗുകൾക്ക്,
ഈ ഫംഗ്‌ഷൻ 0 നൽകുന്നു; അനുവദനീയമായ ഓവർലോംഗ് സീക്വൻസുകൾക്ക്, കമ്പ്യൂട്ട് ചെയ്ത കോഡ് പോയിന്റ്
തിരിച്ചയച്ചു; അനുവദനീയമായ മറ്റെല്ലാ തകരാറുകൾക്കും, യൂണികോഡ് റീപ്ലേസ്മെന്റ്
നിർണ്ണായകമായ ന്യായമായ മൂല്യം ഇല്ലാത്തതിനാൽ CHARACTER തിരികെ നൽകുന്നു.

UTF8_CHECK_ONLY ഫ്ലാഗ് അനുവദനീയമല്ലാത്ത പെരുമാറ്റത്തെ മറികടക്കുന്നു (മറ്റുള്ളവർ
പതാകകൾ) അപാകത കണ്ടെത്തി. ഈ ഫ്ലാഗ് സജ്ജീകരിച്ചാൽ, ദിനചര്യ അനുമാനിക്കുന്നു
വിളിക്കുന്നയാൾ ഒരു മുന്നറിയിപ്പ് ഉയർത്തും, ഈ പ്രവർത്തനം നിശബ്ദമായി "retlen" ആയി സജ്ജീകരിക്കും
"-1" ("STRLEN" എന്നതിലേക്ക് കാസ്റ്റ് ചെയ്യുക) പൂജ്യം തിരികെ നൽകുക.

"NUL" വിജയകരമായ ഡീകോഡ് ചെയ്യുന്നതിനിടയിൽ ഈ API-ന് അവ്യക്തത ആവശ്യമാണെന്ന കാര്യം ശ്രദ്ധിക്കുക
പ്രതീകം, ഒരു പിശക് റിട്ടേൺ (UTF8_CHECK_ONLY ഫ്ലാഗ് സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ), എന്നതുപോലെ
രണ്ട് സന്ദർഭങ്ങളിലും, 0 തിരികെ നൽകുന്നു. വ്യക്തത വരുത്താൻ, പൂജ്യം മടങ്ങുമ്പോൾ, ആദ്യത്തേതാണോ എന്ന് നോക്കുക
"s" ന്റെ ബൈറ്റ് 0 ആണ്. അങ്ങനെയാണെങ്കിൽ, ഇൻപുട്ട് ഒരു "NUL" ആയിരുന്നു; ഇല്ലെങ്കിൽ, ഇൻപുട്ടിന് ഒരു ഉണ്ടായിരുന്നു
പിശക്.

ചില കോഡ് പോയിന്റുകൾ പ്രശ്നമുള്ളതായി കണക്കാക്കുന്നു. ഇവ യൂണികോഡ് സറോഗേറ്റുകളാണ്,
യൂണികോഡ് ഇതര പ്രതീകങ്ങൾ, കൂടാതെ യൂണികോഡ് പരമാവധി 0x10FFFF-ന് മുകളിലുള്ള കോഡ് പോയിന്റുകൾ. എഴുതിയത്
സ്ഥിരസ്ഥിതിയായി ഇവ സാധാരണ കോഡ് പോയിന്റുകളായി കണക്കാക്കപ്പെടുന്നു, എന്നാൽ ചില സാഹചര്യങ്ങൾ വാറണ്ട്
അവർക്കായി പ്രത്യേക കൈകാര്യം ചെയ്യൽ. "ഫ്ലാഗുകളിൽ" UTF8_DISALLOW_ILLEGAL_INTERCHANGE അടങ്ങിയിട്ടുണ്ടെങ്കിൽ,
മൂന്ന് ക്ലാസുകളും വൈകല്യങ്ങളായി കണക്കാക്കുകയും അവ കൈകാര്യം ചെയ്യുകയും ചെയ്യുന്നു. പതാകകൾ
UTF8_DISALLOW_SURROGATE, UTF8_DISALLOW_NONCHAR, UTF8_DISALLOW_SUPER (അർത്ഥം
നിയമപരമായ യൂണികോഡിന് മുകളിൽ) ഈ വിഭാഗങ്ങളെ അനുവദിക്കാതിരിക്കാൻ സജ്ജീകരിക്കാം
വ്യക്തിഗതമായി.

ഫ്ലാഗുകൾ UTF8_WARN_ILLEGAL_INTERCHANGE, UTF8_WARN_SURROGATE, UTF8_WARN_NONCHAR,
കൂടാതെ UTF8_WARN_SUPER അവയ്‌ക്കായി മുന്നറിയിപ്പ് സന്ദേശങ്ങൾ ഉയർത്താൻ ഇടയാക്കും
വിഭാഗങ്ങൾ, എന്നാൽ കോഡ് പോയിന്റുകൾ സാധുതയുള്ളതായി കണക്കാക്കുന്നു (അല്ല
അപാകതകൾ). രണ്ടിനും ഒരു വിഭാഗം ലഭിക്കുന്നതിന്, ഒരു വികലമായി കണക്കാക്കുകയും ഉയർത്തുകയും ചെയ്യുക
ഒരു മുന്നറിയിപ്പ്, WARN, DISALLOW ഫ്ലാഗുകൾ വ്യക്തമാക്കുക. (എന്നാൽ മുന്നറിയിപ്പുകളാണെന്ന കാര്യം ശ്രദ്ധിക്കുക
പദാനുപദമായി അപ്രാപ്‌തമാക്കിയിട്ടുണ്ടെങ്കിലോ UTF8_CHECK_ONLY എന്നതും വ്യക്തമാക്കിയിട്ടില്ലെങ്കിലോ ഉയർത്തില്ല.)

വളരെ വലിയ കോഡ് പോയിന്റുകൾ (0x7FFF_FFFF-ന് മുകളിൽ) കൂടുതൽ പ്രശ്‌നകരമായി കണക്കാക്കുന്നു
മറ്റുള്ളവ യൂണികോഡ് നിയമപരമായ പരമാവധിയ്ക്ക് മുകളിലാണ്. നിരവധി കാരണങ്ങളുണ്ട്:
ASCII പ്ലാറ്റ്‌ഫോമുകളിൽ അവയെ പ്രതിനിധീകരിക്കാൻ അവർക്ക് കുറഞ്ഞത് 32 ബിറ്റുകൾ ആവശ്യമാണ്, അല്ല
EBCDIC പ്ലാറ്റ്‌ഫോമുകളിലും യഥാർത്ഥ UTF-8 സ്പെസിഫിക്കേഷനിലും പ്രതിനിധാനം ചെയ്യാവുന്നതാണ്
ഒരിക്കലും ഈ സംഖ്യയ്ക്ക് മുകളിൽ പോയിട്ടില്ല (നിലവിലെ 0x10FFFF പരിധി പിന്നീട് ഏർപ്പെടുത്തി). (ദി
ചെറിയവ, 32 ബിറ്റുകളിലേക്ക് യോജിക്കുന്നവ, ASCII-യിലെ UV മുഖേന പ്രതിനിധീകരിക്കുന്നു
പ്ലാറ്റ്‌ഫോമുകൾ, പക്ഷേ ഒരു IV വഴിയല്ല, അതായത് പ്രവർത്തനങ്ങളുടെ എണ്ണം
അവയിൽ നടപ്പിലാക്കുന്നത് തികച്ചും നിയന്ത്രിതമാണ്.) ഇതിനായി ASCII പ്ലാറ്റ്‌ഫോമുകളിലെ UTF-8 എൻകോഡിംഗ്
ഈ വലിയ കോഡ് പോയിന്റുകൾ ആരംഭിക്കുന്നത് 0xFE അല്ലെങ്കിൽ 0xFF അടങ്ങിയ ഒരു ബൈറ്റ് ഉപയോഗിച്ചാണ്. ദി
UTF8_DISALLOW_FE_FF ഫ്ലാഗ് അവയെ തകരാറുകളായി കണക്കാക്കാൻ ഇടയാക്കും, അതേസമയം
ചെറിയ മുകളിലെ യൂണികോഡ് കോഡ് പോയിന്റുകൾ അനുവദിക്കുന്നു. (തീർച്ചയായും UTF8_DISALLOW_SUPER ചെയ്യും
ഇവയുൾപ്പെടെ മുകളിലുള്ള എല്ലാ യൂണികോഡ് കോഡ് പോയിന്റുകളും തകരാറുകളായി കണക്കാക്കുക.)
അതുപോലെ, UTF8_WARN_FE_FF മറ്റ് WARN ഫ്ലാഗുകളെപ്പോലെ പ്രവർത്തിക്കുന്നു, പക്ഷേ ഇത് ബാധകമാണ്
ഈ കോഡ് പോയിന്റുകളിലേക്ക്.

സ്വകാര്യ ഉപയോഗം ഉൾപ്പെടെ, യൂണികോഡ് പ്രതീകങ്ങളുമായി ബന്ധപ്പെട്ട മറ്റെല്ലാ കോഡ് പോയിന്റുകളും
ഇനിയും അസൈൻ ചെയ്യപ്പെടേണ്ടവരെ ഒരിക്കലും വികലമായി കണക്കാക്കില്ല, മുന്നറിയിപ്പ് നൽകുന്നില്ല.

UV utf8n_to_uvchr(const U8 *s, STRLEN ചുരുളൻ,
STRLEN *retlen, U32 ഫ്ലാഗുകൾ)

utf8n_to_uvuni
പകരം "utf8_to_uvchr_buf" അല്ലെങ്കിൽ അപൂർവ്വമായി "utf8n_to_uvchr" ഉപയോഗിക്കുക.

EBCDIC, ASCII എന്നിവ കൈകാര്യം ചെയ്യാൻ ആഗ്രഹിക്കുന്ന കോഡിന് ഈ പ്രവർത്തനം ഉപയോഗപ്രദമായിരുന്നു
യൂണികോഡ് ഗുണങ്ങളുള്ള പ്ലാറ്റ്‌ഫോമുകൾ, എന്നാൽ Perl v5.20-ൽ ആരംഭിക്കുന്നു, വ്യത്യാസങ്ങൾ
പ്ലാറ്റ്‌ഫോമുകൾക്കിടയിൽ മിക്ക കോഡിനും അദൃശ്യമാക്കിയിരിക്കുന്നു, അതിനാൽ ഇത്
ഫംഗ്‌ഷൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നത് ആകാൻ സാധ്യതയില്ല. നിങ്ങൾക്ക് ഇത് കൃത്യമായി വേണമെങ്കിൽ
പ്രവർത്തനക്ഷമത, പകരം "NATIVE_TO_UNI(utf8_to_uvchr_buf(...))" അല്ലെങ്കിൽ ഉപയോഗിക്കുക
"NATIVE_TO_UNI(utf8n_to_uvchr(...))".

UV utf8n_to_uvuni(const U8 *s, STRLEN ചുരുളൻ,
STRLEN *retlen, U32 ഫ്ലാഗുകൾ)

UTF8SKIP
UTF-8 എൻകോഡ് ചെയ്‌ത പ്രതീകത്തിലെ ബൈറ്റുകളുടെ എണ്ണം നൽകുന്നു, അതിന്റെ ആദ്യത്തേത് (ഒരുപക്ഷേ
മാത്രം) ബൈറ്റ് "s" കൊണ്ട് ചൂണ്ടിക്കാണിക്കുന്നു.

STRLEN UTF8SKIP(char*s)

utf8_ദൂരം
UTF-8 പോയിന്ററുകൾ "a", "b" എന്നിവയ്ക്കിടയിലുള്ള UTF-8 പ്രതീകങ്ങളുടെ എണ്ണം നൽകുന്നു.

മുന്നറിയിപ്പ്: പോയിന്ററുകൾ ഒരേ UTF-8-ന്റെ ഉള്ളിൽ ചൂണ്ടിക്കാണിക്കുന്നുവെന്ന് നിങ്ങൾക്ക് *അറിയാമെങ്കിൽ* മാത്രം ഉപയോഗിക്കുക
ബഫർ.

IV utf8_distance(const U8 *a, const U8 *b)

utf8_hop
ഫോർവേഡ് അല്ലെങ്കിൽ ഫോർവേഡ് അല്ലെങ്കിൽ "ഓഫ്" പ്രതീകങ്ങളാൽ സ്ഥാനഭ്രംശം വരുത്തിയ UTF-8 പോയിന്റർ "s" തിരികെ നൽകുക
പിന്നോക്ക.

മുന്നറിയിപ്പ്: UTF-8 ഡാറ്റയ്ക്കുള്ളിൽ "ഓഫ്" ആണെന്ന് നിങ്ങൾക്ക് *അറിയില്ലെങ്കിൽ* ഇനിപ്പറയുന്നവ ഉപയോഗിക്കരുത്
"s" ചൂണ്ടിക്കാണിക്കുന്നു * കൂടാതെ* എൻട്രിയിൽ "s" യുടെ ആദ്യ ബൈറ്റിൽ വിന്യസിച്ചിരിക്കുന്നു
പ്രതീകം അല്ലെങ്കിൽ ഒരു പ്രതീകത്തിന്റെ അവസാന ബൈറ്റിന് ശേഷം.

U8* utf8_hop(const U8 *s, I32 off)

utf8_length
പ്രതീകങ്ങളിൽ UTF-8 ചാർ എൻകോഡ് ചെയ്ത "s" സ്ട്രിംഗിന്റെ ദൈർഘ്യം തിരികെ നൽകുക. നിർത്തുന്നു
"ഇ" (ഉൾപ്പെടെ). "e < s" ആണെങ്കിലോ സ്കാൻ "e" കഴിഞ്ഞാൽ അവസാനിക്കുമോ, croaks.

STRLEN utf8_length(const U8* s, const U8 *e)

utf8_to_bytes
ശ്രദ്ധിക്കുക: ഈ ഫംഗ്‌ഷൻ പരീക്ഷണാത്മകമാണ്, അറിയിപ്പ് കൂടാതെ മാറ്റുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യാം.

UTF-8-ൽ നിന്ന് "ലെൻ" നീളമുള്ള "s" സ്ട്രിംഗ് നേറ്റീവ് ബൈറ്റ് എൻകോഡിംഗിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു.
"bytes_to_utf8" പോലെയല്ല, ഇത് യഥാർത്ഥ സ്ട്രിംഗിനെ അധികമായി എഴുതുകയും "len" അപ്ഡേറ്റ് ചെയ്യുകയും ചെയ്യുന്നു
പുതിയ നീളം ഉൾക്കൊള്ളുന്നു. പരാജയത്തിൽ പൂജ്യം നൽകുന്നു, "len" -1 ആയി സജ്ജീകരിക്കുന്നു.

നിങ്ങൾക്ക് സ്ട്രിംഗിന്റെ ഒരു പകർപ്പ് ആവശ്യമുണ്ടെങ്കിൽ, "bytes_from_utf8" കാണുക.

U8* utf8_to_bytes(U8 *s, STRLEN *len)

utf8_to_uvchr_buf
"s" എന്ന സ്ട്രിംഗിലെ ആദ്യ പ്രതീകത്തിന്റെ നേറ്റീവ് കോഡ് പോയിന്റ് നൽകുന്നു
UTF-8 എൻകോഡിംഗിലാണെന്ന് അനുമാനിക്കുന്നു; "s" എന്നതിന്റെ അവസാനത്തിനപ്പുറം 1 ലേക്ക് "send" പോയിൻറുകൾ.
*retlen ആ പ്രതീകത്തിന്റെ നീളം, ബൈറ്റുകളിൽ സജ്ജീകരിക്കും.

"s" നന്നായി രൂപപ്പെട്ട UTF-8 പ്രതീകത്തിലേക്ക് വിരൽ ചൂണ്ടുന്നില്ലെങ്കിൽ UTF8 മുന്നറിയിപ്പുകളാണ്
പ്രവർത്തനക്ഷമമാക്കി, പൂജ്യം തിരികെ നൽകുകയും *retlen ("retlen" NULL അല്ലെങ്കിൽ) -1 ആയി സജ്ജീകരിക്കുകയും ചെയ്യുന്നു. എങ്കിൽ
ആ മുന്നറിയിപ്പുകൾ ഓഫാണ്, കണക്കുകൂട്ടിയ മൂല്യം, നന്നായി നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ (അല്ലെങ്കിൽ യൂണികോഡ്
പകരം വയ്ക്കൽ പ്രതീകം ഇല്ലെങ്കിൽ), നിശബ്ദമായി തിരികെ നൽകുകയും *retlen സജ്ജീകരിക്കുകയും ചെയ്യുന്നു (എങ്കിൽ
"retlen" NULL അല്ല) അതിനാൽ ("s" + *retlen) ആണ് "s" ലെ അടുത്ത സാധ്യമായ സ്ഥാനം
അതൊരു വികലമായ സ്വഭാവം ആരംഭിക്കും. വിശദാംശങ്ങൾക്ക് "utf8n_to_uvchr" കാണുക
REPLACEMENT CHARACTER തിരികെ നൽകുമ്പോൾ.

UV utf8_to_uvchr_buf(const U8 *s, const U8 *send,
STRLEN *retlen)

utf8_to_uvuni_buf
ഒഴിവാക്കി! പേളിന്റെ ഭാവി റിലീസിൽ നിന്ന് ഈ ഫംഗ്‌ഷൻ നീക്കം ചെയ്യാൻ പദ്ധതിയിട്ടിട്ടുണ്ട്.
പുതിയ കോഡിനായി ഇത് ഉപയോഗിക്കരുത്; നിലവിലുള്ള കോഡിൽ നിന്ന് അത് നീക്കം ചെയ്യുക.

വളരെ അപൂർവമായ സന്ദർഭങ്ങളിൽ മാത്രമേ യൂണികോഡിൽ കോഡ് കൈകാര്യം ചെയ്യേണ്ടതുള്ളൂ (അതുപോലെ
നേറ്റീവ്) കോഡ് പോയിന്റുകൾക്ക് എതിരാണ്. അത്തരം കുറച്ച് സന്ദർഭങ്ങളിൽ, ഉപയോഗിക്കുക
പകരം "NATIVE_TO_UNI(utf8_to_uvchr_buf(...))".

സ്‌ട്രിംഗിലെ ആദ്യ പ്രതീകത്തിന്റെ യൂണികോഡ് (നേറ്റീവ് അല്ല) കോഡ് പോയിന്റ് നൽകുന്നു
UTF-8 എൻകോഡിംഗിലാണെന്ന് അനുമാനിക്കപ്പെടുന്ന "s"; "അയയ്‌ക്കുക" എന്നതിന്റെ അവസാനത്തിനപ്പുറം 1 ലേക്ക് പോയിന്റുകൾ
"s". "retlen" എന്നത് ആ പ്രതീകത്തിന്റെ നീളം, ബൈറ്റുകളിൽ സജ്ജീകരിക്കും.

"s" നന്നായി രൂപപ്പെട്ട UTF-8 പ്രതീകത്തിലേക്ക് വിരൽ ചൂണ്ടുന്നില്ലെങ്കിൽ UTF8 മുന്നറിയിപ്പുകളാണ്
പ്രവർത്തനക്ഷമമാക്കി, പൂജ്യം തിരികെ നൽകുകയും *retlen ("retlen" NULL അല്ലെങ്കിൽ) -1 ആയി സജ്ജീകരിക്കുകയും ചെയ്യുന്നു. എങ്കിൽ
ആ മുന്നറിയിപ്പുകൾ ഓഫാണ്, നന്നായി നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ (അല്ലെങ്കിൽ യൂണികോഡ്) കണക്കാക്കിയ മൂല്യം
മാറ്റിസ്ഥാപിക്കൽ പ്രതീകം, ഇല്ലെങ്കിൽ) നിശബ്ദമായി തിരികെ നൽകുകയും *retlen സജ്ജീകരിക്കുകയും ചെയ്യുന്നു (എങ്കിൽ
"retlen" NULL അല്ല) അതിനാൽ ("s" + *retlen) ആണ് "s" ലെ അടുത്ത സാധ്യമായ സ്ഥാനം
അതൊരു വികലമായ സ്വഭാവം ആരംഭിക്കും. വിശദാംശങ്ങൾക്ക് "utf8n_to_uvchr" കാണുക
REPLACEMENT CHARACTER തിരികെ നൽകുമ്പോൾ.

UV utf8_to_uvuni_buf(const U8 *s, const U8 *send,
STRLEN *retlen)

UVCHR_SKIP
എൻകോഡ് ചെയ്യുമ്പോൾ "cp" എന്ന കോഡ് പോയിന്റിനെ പ്രതിനിധീകരിക്കാൻ ആവശ്യമായ ബൈറ്റുകളുടെ എണ്ണം നൽകുന്നു
UTF-8 ആയി. 255-ൽ കുറവാണെങ്കിൽ "cp" ഒരു നേറ്റീവ് (ASCII അല്ലെങ്കിൽ EBCDIC) കോഡ് പോയിന്റാണ്; എ
അല്ലാത്തപക്ഷം യൂണികോഡ് കോഡ് പോയിന്റ്.

STRLEN UVCHR_SKIP(UV cp)

uvchr_to_utf8
"uv" എന്ന നേറ്റീവ് കോഡ് പോയിന്റിന്റെ UTF-8 പ്രാതിനിധ്യം ഇതിന്റെ അവസാനം ചേർക്കുന്നു
സ്ട്രിംഗ് "d"; "d" ൽ കുറഞ്ഞത് "UVCHR_SKIP(uv)+1" ("UTF8_MAXBYTES+1" വരെ) ഉണ്ടായിരിക്കണം
സൗജന്യ ബൈറ്റുകൾ ലഭ്യമാണ്. അവസാനിച്ചതിന് ശേഷമുള്ള ബൈറ്റിലേക്കുള്ള പോയിന്ററാണ് റിട്ടേൺ മൂല്യം
പുതിയ കഥാപാത്രത്തിന്റെ. മറ്റൊരു വാക്കിൽ,

d = uvchr_to_utf8(d, uv);

ശുപാർശ ചെയ്യുന്ന വൈഡ് നേറ്റീവ് സ്വഭാവ ബോധമുള്ള രീതിയാണ്

*(d++) = uv;

ഈ ഫംഗ്‌ഷൻ ഏതൊരു യുവിയെയും ഇൻപുട്ടായി സ്വീകരിക്കുന്നു. യൂണികോഡ് ഇതര കോഡ് നിരോധിക്കുകയോ മുന്നറിയിപ്പ് നൽകുകയോ ചെയ്യുക
പോയിന്റുകൾ, അല്ലെങ്കിൽ പ്രശ്നമുള്ളവ, "uvchr_to_utf8_flags" കാണുക.

U8* uvchr_to_utf8(U8 *d, UV uv)

uvchr_to_utf8_flags
"uv" എന്ന നേറ്റീവ് കോഡ് പോയിന്റിന്റെ UTF-8 പ്രാതിനിധ്യം ഇതിന്റെ അവസാനം ചേർക്കുന്നു
സ്ട്രിംഗ് "d"; "d" ൽ കുറഞ്ഞത് "UVCHR_SKIP(uv)+1" ("UTF8_MAXBYTES+1" വരെ) ഉണ്ടായിരിക്കണം
സൗജന്യ ബൈറ്റുകൾ ലഭ്യമാണ്. അവസാനിച്ചതിന് ശേഷമുള്ള ബൈറ്റിലേക്കുള്ള പോയിന്ററാണ് റിട്ടേൺ മൂല്യം
പുതിയ കഥാപാത്രത്തിന്റെ. മറ്റൊരു വാക്കിൽ,

d = uvchr_to_utf8_flags (d, uv, ഫ്ലാഗുകൾ);

അല്ലെങ്കിൽ, മിക്ക കേസുകളിലും,

d = uvchr_to_utf8_flags(d, uv, 0);

ഇതാണ് യൂണികോഡ് ബോധമുള്ള രീതി

*(d++) = uv;

ഈ ഫംഗ്‌ഷൻ UTF-8-ലേക്ക് പരിവർത്തനം ചെയ്യും (അല്ലാത്ത കോഡ് പോയിന്റുകൾ പോലും).
"പതാക"കളിൽ ഒന്നോ അതിലധികമോ ഉൾപ്പെടുന്നില്ലെങ്കിൽ നിയമപരമായ യൂണിക്കോഡ് അല്ലെങ്കിൽ പ്രശ്നമുള്ളവയാണ്
ഇനിപ്പറയുന്ന പതാകകൾ:

"uv" എന്നത് ഒരു യൂണികോഡ് സറോഗേറ്റ് കോഡ് പോയിന്റാണെങ്കിൽ UNICODE_WARN_SURROGATE സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ,
UTF8 മുന്നറിയിപ്പുകൾ പ്രവർത്തനക്ഷമമാക്കിയിട്ടുണ്ടെങ്കിൽ, പ്രവർത്തനം ഒരു മുന്നറിയിപ്പ് ഉയർത്തും. പകരം എങ്കിൽ
UNICODE_DISALLOW_SURROGATE സജ്ജമാക്കി, ഫംഗ്‌ഷൻ പരാജയപ്പെടുകയും NULL തിരികെ നൽകുകയും ചെയ്യും. എങ്കിൽ
രണ്ട് ഫ്ലാഗുകളും സജ്ജീകരിച്ചിരിക്കുന്നു, ഫംഗ്ഷൻ NULL മുന്നറിയിപ്പ് നൽകുകയും തിരികെ നൽകുകയും ചെയ്യും.

UNICODE_WARN_NONCHAR, UNICODE_DISALLOW_NONCHAR ഫ്ലാഗുകൾ എങ്ങനെ ബാധിക്കുന്നു
ഫംഗ്‌ഷൻ ഒരു യൂണികോഡ് ഇതര പ്രതീകം കൈകാര്യം ചെയ്യുന്നു. അതുപോലെ, UNICODE_WARN_SUPER
കൂടാതെ UNICODE_DISALLOW_SUPER ഫ്ലാഗുകൾ മുകളിലുള്ള കോഡ് പോയിന്റുകൾ കൈകാര്യം ചെയ്യുന്നതിനെ ബാധിക്കുന്നു
യൂണികോഡ് പരമാവധി 0x10FFFF. 0x7FFF_FFFF-ന് മുകളിലുള്ള കോഡ് പോയിന്റുകൾ (ഇവ തുല്യമാണ്
കുറവ് പോർട്ടബിൾ) മറ്റ് യൂണികോഡ് കോഡുകൾക്ക് മുകളിലാണെങ്കിൽപ്പോലും മുന്നറിയിപ്പ് നൽകാനും കൂടാതെ/അല്ലെങ്കിൽ അനുവദിക്കാതിരിക്കാനും കഴിയും
പോയിന്റുകൾ UNICODE_WARN_FE_FF, UNICODE_DISALLOW_FE_FF ഫ്ലാഗുകൾ അംഗീകരിച്ചു.

ഒടുവിൽ, ഫ്ലാഗ് UNICODE_WARN_ILLEGAL_INTERCHANGE നാലെണ്ണവും തിരഞ്ഞെടുക്കുന്നു
WARN ഫ്ലാഗുകൾക്ക് മുകളിൽ; കൂടാതെ UNICODE_DISALLOW_ILLEGAL_INTERCHANGE നാലെണ്ണവും തിരഞ്ഞെടുക്കുന്നു
പതാകകൾ അനുവദിക്കാതിരിക്കുക.

U8* uvchr_to_utf8_flags(U8 *d, UV uv, UV ഫ്ലാഗുകൾ)

uvoffuni_to_utf8_flags
ഈ ഫംഗ്ഷൻ വളരെ പ്രത്യേകമായ സാഹചര്യങ്ങളിൽ മാത്രമേ ഉപയോഗിക്കാവൂ. പകരം,
മിക്കവാറും എല്ലാം കോഡ് വേണം ഉപയോഗം "uvchr_to_utf8" or "uvchr_to_utf8_flags".

ഈ ഫംഗ്‌ഷൻ അവ പോലെയാണ്, എന്നാൽ ഇൻപുട്ട് ഒരു കർശനമായ യൂണികോഡ് ആണ് (ഇതിൽ നിന്ന് വിപരീതമായി
നേറ്റീവ്) കോഡ് പോയിന്റ്. വളരെ അപൂർവമായ സന്ദർഭങ്ങളിൽ മാത്രം കോഡ് ഉപയോഗിക്കരുത്
നേറ്റീവ് കോഡ് പോയിന്റ്.

വിശദാംശങ്ങൾക്ക്, "uvchr_to_utf8_flags" എന്നതിനായുള്ള വിവരണം കാണുക.

U8* uvoffuni_to_utf8_flags(U8 *d, UV uv, UV ഫ്ലാഗുകൾ)

uvuni_to_utf8_flags
പകരം "uvchr_to_utf8" അല്ലെങ്കിൽ "uvchr_to_utf8_flags" ഉപയോഗിക്കാൻ നിങ്ങൾ തീർച്ചയായും ആഗ്രഹിക്കുന്നു.

ഈ ഫംഗ്‌ഷൻ "uvoffuni_to_utf8_flags" എന്നതിന്റെ പര്യായപദമാണ്, അത് തന്നെ,
ഒഴിവാക്കിയിട്ടില്ലെങ്കിലും, ഒറ്റപ്പെട്ട സാഹചര്യങ്ങളിൽ മാത്രമേ ഉപയോഗിക്കാവൂ. ഇവ
EBCDIC, ASCII എന്നിവ കൈകാര്യം ചെയ്യാൻ ആഗ്രഹിക്കുന്ന കോഡിന് ഫംഗ്ഷനുകൾ ഉപയോഗപ്രദമായിരുന്നു
യൂണികോഡ് ഗുണങ്ങളുള്ള പ്ലാറ്റ്‌ഫോമുകൾ, എന്നാൽ Perl v5.20-ൽ ആരംഭിക്കുന്നു, വ്യത്യാസങ്ങൾ
പ്ലാറ്റ്‌ഫോമുകൾക്കിടയിൽ മിക്ക കോഡിനും അദൃശ്യമാക്കിയിരിക്കുന്നു, അതിനാൽ ഇത്
ഫംഗ്‌ഷൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നത് ആകാൻ സാധ്യതയില്ല.

U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV ഫ്ലാഗുകൾ)

വേരിയബിളുകൾ സൃഷ്ടിച്ചു by "xsubpp" ഒപ്പം "xsubpp" ആന്തരിക ഫംഗ്ഷനുകളും

newXSproto
XSUB-കളെ Perl സബ്‌സായി ഹുക്ക് അപ്പ് ചെയ്യാൻ "xsubpp" ഉപയോഗിക്കുന്നു. സബ്‌സുകളിലേക്ക് പേൾ പ്രോട്ടോടൈപ്പുകൾ ചേർക്കുന്നു.

XS_APIVERSION_BOOTCHECK
perl api പതിപ്പ് ഒരു XS മൊഡ്യൂളിനെതിരെ കംപൈൽ ചെയ്തിട്ടുണ്ടോയെന്ന് പരിശോധിക്കാൻ മാക്രോ
അത് ലോഡുചെയ്യുന്ന perl ഇന്റർപ്രെറ്ററിന്റെ api പതിപ്പുമായി പൊരുത്തപ്പെടുന്നു.

XS_APIVERSION_BOOTCHECK;

XS_VERSION
ഒരു XS മൊഡ്യൂളിനുള്ള പതിപ്പ് ഐഡന്റിഫയർ. ഇത് സാധാരണയായി സ്വയമേവ കൈകാര്യം ചെയ്യുന്നു
"ExtUtils:: MakeMaker". "XS_VERSION_BOOTCHECK" കാണുക.

XS_VERSION_BOOTCHECK
ഒരു PM മൊഡ്യൂളിന്റെ $VERSION വേരിയബിൾ XS മൊഡ്യൂളുമായി പൊരുത്തപ്പെടുന്നുണ്ടോയെന്ന് പരിശോധിക്കാൻ മാക്രോ
"XS_VERSION" വേരിയബിൾ. ഇത് സാധാരണയായി "xsubpp" സ്വയമേവ കൈകാര്യം ചെയ്യുന്നു. കാണുക
perlxs-ൽ "ദി വേർഷൻ ചെക്ക്: കീവേഡ്".

XS_VERSION_BOOTCHECK;

പതിപ്പുകൾ

പുതിയ_പതിപ്പ്
എസ്‌വിയിൽ പാസാക്കിയതിനെ അടിസ്ഥാനമാക്കി ഒരു പുതിയ പതിപ്പ് ഒബ്‌ജക്റ്റ് നൽകുന്നു:

SV *sv = new_version(SV *ver);

ver SV-ൽ പാസാക്കിയതിൽ മാറ്റം വരുത്തുന്നില്ല. നിങ്ങൾക്ക് നവീകരിക്കണമെങ്കിൽ "upg_version" കാണുക
എസ്.വി.

SV* new_version(SV *ver)

പ്രെസ്കാൻ_പതിപ്പ്
തന്നിരിക്കുന്ന ഒരു സ്‌ട്രിംഗ് ഒരു പതിപ്പ് ഒബ്‌ജക്‌റ്റായി പാഴ്‌സ് ചെയ്യാൻ കഴിയുമെന്ന് സാധൂകരിക്കുക, പക്ഷേ അങ്ങനെയല്ല
യഥാർത്ഥത്തിൽ പാഴ്സിംഗ് നടത്തുക. കർശനമായ അല്ലെങ്കിൽ അയഞ്ഞ മൂല്യനിർണ്ണയ നിയമങ്ങൾ ഉപയോഗിക്കാം. കഴിയും
പാഴ്‌സിംഗ് കോഡ് കുറച്ച് സമയം സേവ് ചെയ്യുന്നതിന് ഓപ്‌ഷണലായി നിരവധി സൂചന വേരിയബിളുകൾ സജ്ജമാക്കുക
അടയാളപ്പെടുത്തൽ.

const char* prescan_version(const char *s, bool strict,
const char** errstr,
bool * sqv,
int *ssaw_decimal,
int *swidth, bool *salpha)

സ്കാൻ_പതിപ്പ്
പാഴ്‌സ് ചെയ്‌ത പതിപ്പ് സ്‌ട്രിങ്ങിന് ശേഷമുള്ള അടുത്ത പ്രതീകത്തിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു
എസ്‌വിയിൽ പാസായതിനെ ആർവിയിലേക്ക് അപ്‌ഗ്രേഡ് ചെയ്യുന്നതുപോലെ.

ഇതിനകം നിലവിലുള്ള ഒരു SV പോലെ ഫംഗ്‌ഷൻ വിളിക്കണം

sv = newSV(0);
s = scan_version(s, SV *sv, bool qv);

സ്‌ട്രിംഗിന് ശരിയായത് ഉണ്ടെന്ന് ഉറപ്പാക്കാൻ ചില പ്രീപ്രോസസ്സിംഗ് നടത്തുന്നു
ഒരു പതിപ്പിന്റെ സവിശേഷതകൾ. ഒബ്‌ജക്‌റ്റിൽ അടിവരയിട്ടാൽ അത് ഫ്ലാഗ് ചെയ്യുന്നു
(ഇത് ഒരു ആൽഫ പതിപ്പാണെന്ന് സൂചിപ്പിക്കുന്നു). ബൂളിയൻ qv പതിപ്പിനെ സൂചിപ്പിക്കുന്നു
ഒന്നിലധികം ദശാംശങ്ങൾ ഉള്ളതുപോലെ വ്യാഖ്യാനിക്കണം, ഇല്ലെങ്കിലും.

const char* scan_version (const char *s, SV *rv, bool qv)

upg_version
ഒരു പതിപ്പ് ഒബ്‌ജക്‌റ്റിലേക്ക് വിതരണം ചെയ്‌ത എസ്‌വിയുടെ ഇൻ-പ്ലേസ് അപ്‌ഗ്രേഡ്.

SV *sv = upg_version(SV *sv, bool qv);

നവീകരിച്ച SV-യിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു. നിങ്ങൾക്ക് നിർബന്ധിക്കണമെങ്കിൽ ബൂളിയൻ qv സജ്ജമാക്കുക
ഈ SV ഒരു "വിപുലീകരിച്ച" പതിപ്പായി വ്യാഖ്യാനിക്കപ്പെടുന്നു.

SV* upg_version(SV *ver, bool qv)

vcmp പതിപ്പ് ഒബ്‌ജക്റ്റ് അവെയർ cmp. രണ്ട് പ്രവർത്തനങ്ങളും ഇതിനകം തന്നെ പരിവർത്തനം ചെയ്തിരിക്കണം
പതിപ്പ് വസ്തുക്കൾ.

int vcmp(SV *lhv, SV *rhv)

vnormal ഒരു പതിപ്പ് ഒബ്ജക്റ്റ് സ്വീകരിക്കുകയും നോർമലൈസ് ചെയ്ത സ്ട്രിംഗ് പ്രാതിനിധ്യം നൽകുകയും ചെയ്യുന്നു. വിളി
പോലെ:

sv = vnormal (rv);

ശ്രദ്ധിക്കുക: നിങ്ങൾക്ക് ഒബ്‌ജക്‌റ്റ് നേരിട്ടോ അല്ലെങ്കിൽ ആർവിയിൽ അടങ്ങിയിരിക്കുന്ന എസ്‌വിയോ കൈമാറാനാകും.

മടങ്ങിയ എസ്‌വിക്ക് 1 റീകൗണ്ട് ഉണ്ട്.

SV* vnormal(SV *vs)

vnumify ഒരു പതിപ്പ് ഒബ്ജക്റ്റ് സ്വീകരിക്കുകയും നോർമലൈസ് ചെയ്ത ഫ്ലോട്ടിംഗ് പോയിന്റ് പ്രാതിനിധ്യം നൽകുകയും ചെയ്യുന്നു.
ഇതുപോലെ വിളിക്കുക:

sv = vnumify (rv);

ശ്രദ്ധിക്കുക: നിങ്ങൾക്ക് ഒബ്‌ജക്‌റ്റ് നേരിട്ടോ അല്ലെങ്കിൽ ആർവിയിൽ അടങ്ങിയിരിക്കുന്ന എസ്‌വിയോ കൈമാറാനാകും.

മടങ്ങിയ എസ്‌വിക്ക് 1 റീകൗണ്ട് ഉണ്ട്.

SV* vnumify(SV *vs)

vstringify
Perl-ന്റെ മുൻ പതിപ്പുകളുമായി പരമാവധി അനുയോജ്യത നിലനിർത്തുന്നതിന്, ഇത്
ഫംഗ്‌ഷൻ ഫ്ലോട്ടിംഗ് പോയിന്റ് നൊട്ടേഷനോ ഒന്നിലധികം ഡോട്ടുകളോ നൽകും
നൊട്ടേഷൻ, യഥാർത്ഥ പതിപ്പിൽ ഒന്നോ അതിലധികമോ ഡോട്ടുകൾ അടങ്ങിയിട്ടുണ്ടോ എന്നതിനെ ആശ്രയിച്ച്,
യഥാക്രമം.

മടങ്ങിയ എസ്‌വിക്ക് 1 റീകൗണ്ട് ഉണ്ട്.

SV* vstringify(SV *vs)

vverify ഒരു പതിപ്പ് ഒബ്‌ജക്റ്റിനായി സാധുവായ ആന്തരിക ഘടന എസ്‌വിയിൽ അടങ്ങിയിരിക്കുന്നുവെന്ന് സാധൂകരിക്കുന്നു. അത്
പതിപ്പ് ഒബ്ജക്റ്റ് (RV) അല്ലെങ്കിൽ ഹാഷ് തന്നെ (HV) കൈമാറാം. എങ്കിൽ
ഘടന സാധുവാണ്, അത് എച്ച്വി തിരികെ നൽകുന്നു. ഘടന അസാധുവാണെങ്കിൽ, അത് തിരികെ നൽകുന്നു
ശൂന്യം.

SV *hv = vverify(sv);

ഇത് ഏറ്റവും കുറഞ്ഞ ഘടനയെ മാത്രമേ സ്ഥിരീകരിക്കുന്നുള്ളൂ എന്നത് ശ്രദ്ധിക്കുക (ആശയക്കുഴപ്പത്തിലാകാതിരിക്കാൻ
അധിക ഹാഷ് എൻട്രികൾ ഉൾപ്പെട്ടേക്കാവുന്ന ഡിറൈവ്ഡ് ക്ലാസുകൾ പ്രകാരം):

SV* vverify(SV *vs)

മുന്നറിയിപ്പ് ഒപ്പം മരിക്കുന്നു

croak ഇത് പേളിന്റെ "ഡൈ" ഫംഗ്‌ഷനിലേക്കുള്ള ഒരു XS ഇന്റർഫേസാണ്.

ഒരു സ്പ്രിന്റ്ഫ് ശൈലിയിലുള്ള ഫോർമാറ്റ് പാറ്റേണും ആർഗ്യുമെന്റ് ലിസ്റ്റും എടുക്കുക. ഇവ ഉത്പാദിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു
ഒരു സ്ട്രിംഗ് സന്ദേശം. സന്ദേശം ഒരു പുതിയ വരിയിൽ അവസാനിക്കുന്നില്ലെങ്കിൽ, അത് അങ്ങനെയായിരിക്കും
വിവരിച്ചതുപോലെ, കോഡിലെ നിലവിലെ സ്ഥാനത്തിന്റെ ചില സൂചനകളോടെ നീട്ടി
"mess_sv" എന്നതിനായി.

ഡിഫോൾട്ടായി നിയന്ത്രണം തിരികെ നൽകിക്കൊണ്ട് പിശക് സന്ദേശം ഒരു അപവാദമായി ഉപയോഗിക്കും
ഏറ്റവും അടുത്തുള്ള "eval", എന്നാൽ ഒരു $SIG{__DIE__} പരിഷ്‌ക്കരണത്തിന് വിധേയമാണ്
ഹാൻഡ്ലർ. ഏത് സാഹചര്യത്തിലും, "ക്രോക്ക്" ഫംഗ്ഷൻ ഒരിക്കലും സാധാരണഗതിയിൽ തിരിച്ചെത്തില്ല.

ചരിത്രപരമായ കാരണങ്ങളാൽ, "പാറ്റ്" അസാധുവാണെങ്കിൽ, "ERRSV" ($@) യുടെ ഉള്ളടക്കം
ഒരു പിശക് സന്ദേശം നിർമ്മിക്കുന്നതിനുപകരം ഒരു പിശക് സന്ദേശമായോ വസ്തുവായോ ഉപയോഗിക്കുന്നു
വാദങ്ങൾ. നിങ്ങൾക്ക് ഒരു നോൺ-സ്ട്രിംഗ് ഒബ്‌ജക്റ്റ് എറിയണമെങ്കിൽ, അല്ലെങ്കിൽ ഒരു പിശക് സന്ദേശം നിർമ്മിക്കുക
ഒരു SV സ്വയം, "croak_sv" ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നതാണ് നല്ലത്, അങ്ങനെയല്ല
"ERRSV" ക്ലോബറിംഗ് ഉൾപ്പെടുന്നു.

ശൂന്യമായ ക്രോക്ക് (കോൺസ്റ്റ് ചാർ *പാറ്റ്, ...)

croak_no_modify
"Perl_croak(aTHX_ "%s", PL_no_modify)" ന് കൃത്യമായി തുല്യമാണ്, എന്നാൽ ടെർസർ ജനറേറ്റുചെയ്യുന്നു
"Perl_croak" ഉപയോഗിക്കുന്നതിനേക്കാൾ ഒബ്ജക്റ്റ് കോഡ്. ഒഴിവാക്കൽ കോഡ് പാതകളിൽ കുറച്ച് കോഡ് ഉപയോഗിച്ചു
സിപിയു കാഷെ മർദ്ദം കുറയ്ക്കുന്നു.

ശൂന്യമായ croak_no_modify()

croak_sv
ഇത് പേളിന്റെ "ഡൈ" ഫംഗ്‌ഷനിലേക്കുള്ള ഒരു XS ഇന്റർഫേസാണ്.

"baseex" എന്നത് ഒരു പിശക് സന്ദേശം അല്ലെങ്കിൽ വസ്തുവാണ്. ഒരു റഫറൻസ് ആണെങ്കിൽ, അത് ഉപയോഗിക്കും
അതു പൊലെ. അല്ലാത്തപക്ഷം ഇത് ഒരു സ്ട്രിംഗായി ഉപയോഗിക്കുന്നു, കൂടാതെ അത് ഒരു പുതിയ വരിയിൽ അവസാനിക്കുന്നില്ലെങ്കിൽ
കോഡിലെ നിലവിലെ സ്ഥാനത്തിന്റെ ചില സൂചനകളോടെ അത് നീട്ടും,
"mess_sv" എന്നതിന് വിവരിച്ചത് പോലെ.

ഡിഫോൾട്ട് റിട്ടേണിംഗ് വഴി, പിശക് സന്ദേശമോ ഒബ്ജക്റ്റോ ഒരു അപവാദമായി ഉപയോഗിക്കും
ഏറ്റവും അടുത്തുള്ള "eval" ലേക്ക് നിയന്ത്രിക്കുക, എന്നാൽ a മുഖേനയുള്ള പരിഷ്ക്കരണത്തിന് വിധേയമാണ്
$SIG{__DIE__} ഹാൻഡ്‌ലർ. ഏത് സാഹചര്യത്തിലും, "croak_sv" ഫംഗ്‌ഷൻ ഒരിക്കലും മടങ്ങിവരില്ല
സാധാരണയായി.

ഒരു ലളിതമായ സ്ട്രിംഗ് സന്ദേശം ഉപയോഗിച്ച് മരിക്കാൻ, "ക്രോക്ക്" ഫംഗ്ഷൻ കൂടുതൽ സൗകര്യപ്രദമായിരിക്കും.

ശൂന്യമായ croak_sv(SV *baseex)

ഡൈ റിട്ടേൺ തരം ഒഴികെ "ക്രോക്ക്" പോലെയാണ് പെരുമാറുന്നത്. അത് മാത്രമേ ഉപയോഗിക്കാവൂ
അവിടെ "OP *" റിട്ടേൺ തരം ആവശ്യമാണ്. പ്രവർത്തനം യഥാർത്ഥത്തിൽ ഒരിക്കലും തിരിച്ചുവരില്ല.

OP * ഡൈ (കോൺസ്റ്റ് ചാർ *പാറ്റ്, ...)

die_sv റിട്ടേൺ തരം ഒഴികെ, "croak_sv" പോലെയാണ് പെരുമാറുന്നത്. അത് ഉപയോഗിക്കണം
"OP *" റിട്ടേൺ തരം ആവശ്യമുള്ളിടത്ത് മാത്രം. പ്രവർത്തനം യഥാർത്ഥത്തിൽ ഒരിക്കലും
തിരികെ വരുത്തുന്നു.

OP * die_sv(SV *baseex)

vcroak ഇത് പേളിന്റെ "ഡൈ" ഫംഗ്‌ഷനിലേക്കുള്ള ഒരു XS ഇന്റർഫേസാണ്.

"pat" ഉം "args" ഉം ഒരു സ്‌പ്രിന്റ്‌എഫ് ശൈലിയിലുള്ള ഫോർമാറ്റ് പാറ്റേണും എൻക്യാപ്‌സുലേറ്റഡ് ആർഗ്യുമെന്റുമാണ്
പട്ടിക. ഒരു സ്ട്രിംഗ് സന്ദേശം സൃഷ്ടിക്കാൻ ഇവ ഉപയോഗിക്കുന്നു. സന്ദേശം അവസാനിക്കുന്നില്ലെങ്കിൽ
ഒരു പുതിയ ലൈൻ ഉപയോഗിച്ച്, അത് നിലവിലെ ചില സൂചനകളോടെ വിപുലീകരിക്കും
"mess_sv" എന്നതിന് വിവരിച്ചിരിക്കുന്നതുപോലെ, കോഡിലെ സ്ഥാനം.

ഡിഫോൾട്ടായി നിയന്ത്രണം തിരികെ നൽകിക്കൊണ്ട് പിശക് സന്ദേശം ഒരു അപവാദമായി ഉപയോഗിക്കും
ഏറ്റവും അടുത്തുള്ള "eval", എന്നാൽ ഒരു $SIG{__DIE__} പരിഷ്‌ക്കരണത്തിന് വിധേയമാണ്
ഹാൻഡ്ലർ. ഏത് സാഹചര്യത്തിലും, "ക്രോക്ക്" ഫംഗ്ഷൻ ഒരിക്കലും സാധാരണഗതിയിൽ തിരിച്ചെത്തില്ല.

ചരിത്രപരമായ കാരണങ്ങളാൽ, "പാറ്റ്" അസാധുവാണെങ്കിൽ, "ERRSV" ($@) യുടെ ഉള്ളടക്കം
ഒരു പിശക് സന്ദേശം നിർമ്മിക്കുന്നതിനുപകരം ഒരു പിശക് സന്ദേശമായോ വസ്തുവായോ ഉപയോഗിക്കുന്നു
വാദങ്ങൾ. നിങ്ങൾക്ക് ഒരു നോൺ-സ്ട്രിംഗ് ഒബ്‌ജക്റ്റ് എറിയണമെങ്കിൽ, അല്ലെങ്കിൽ ഒരു പിശക് സന്ദേശം നിർമ്മിക്കുക
ഒരു SV സ്വയം, "croak_sv" ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നതാണ് നല്ലത്, അങ്ങനെയല്ല
"ERRSV" ക്ലോബറിംഗ് ഉൾപ്പെടുന്നു.

void vcroak (const char *pat, va_list *args)

vwarn ഇത് പേളിന്റെ "മുന്നറിയിപ്പ്" ഫംഗ്‌ഷനിലേക്കുള്ള ഒരു XS ഇന്റർഫേസാണ്.

"pat" ഉം "args" ഉം ഒരു സ്‌പ്രിന്റ്‌എഫ് ശൈലിയിലുള്ള ഫോർമാറ്റ് പാറ്റേണും എൻക്യാപ്‌സുലേറ്റഡ് ആർഗ്യുമെന്റുമാണ്
പട്ടിക. ഒരു സ്ട്രിംഗ് സന്ദേശം സൃഷ്ടിക്കാൻ ഇവ ഉപയോഗിക്കുന്നു. സന്ദേശം അവസാനിക്കുന്നില്ലെങ്കിൽ
ഒരു പുതിയ ലൈൻ ഉപയോഗിച്ച്, അത് നിലവിലെ ചില സൂചനകളോടെ വിപുലീകരിക്കും
"mess_sv" എന്നതിന് വിവരിച്ചിരിക്കുന്നതുപോലെ, കോഡിലെ സ്ഥാനം.

പിശക് സന്ദേശം അല്ലെങ്കിൽ ഒബ്ജക്റ്റ് സ്ഥിരസ്ഥിതിയായി സാധാരണ പിശകിലേക്ക് എഴുതപ്പെടും, പക്ഷേ ഇത്
ഒരു $SIG{__WARN__} ഹാൻഡ്‌ലറുടെ പരിഷ്‌ക്കരണത്തിന് വിധേയമാണ്.

"vcroak" എന്നതിൽ നിന്ന് വ്യത്യസ്തമായി, "pat" അസാധുവാകാൻ അനുവദനീയമല്ല.

void vwarn (const char *pat, va_list *args)

warn ഇത് പേളിന്റെ "മുന്നറിയിപ്പ്" ഫംഗ്‌ഷനിലേക്കുള്ള ഒരു XS ഇന്റർഫേസാണ്.

ഒരു സ്പ്രിന്റ്ഫ് ശൈലിയിലുള്ള ഫോർമാറ്റ് പാറ്റേണും ആർഗ്യുമെന്റ് ലിസ്റ്റും എടുക്കുക. ഇവ ഉത്പാദിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു
ഒരു സ്ട്രിംഗ് സന്ദേശം. സന്ദേശം ഒരു പുതിയ വരിയിൽ അവസാനിക്കുന്നില്ലെങ്കിൽ, അത് അങ്ങനെയായിരിക്കും
വിവരിച്ചതുപോലെ, കോഡിലെ നിലവിലെ സ്ഥാനത്തിന്റെ ചില സൂചനകളോടെ നീട്ടി
"mess_sv" എന്നതിനായി.

പിശക് സന്ദേശം അല്ലെങ്കിൽ ഒബ്ജക്റ്റ് സ്ഥിരസ്ഥിതിയായി സാധാരണ പിശകിലേക്ക് എഴുതപ്പെടും, പക്ഷേ ഇത്
ഒരു $SIG{__WARN__} ഹാൻഡ്‌ലറുടെ പരിഷ്‌ക്കരണത്തിന് വിധേയമാണ്.

"ക്രോക്ക്" പോലെയല്ല, "പാറ്റ്" അസാധുവാകാൻ അനുവദനീയമല്ല.

അസാധുവായ മുന്നറിയിപ്പ് (const char *pat, ...)

warn_sv ഇത് പേളിന്റെ "മുന്നറിയിപ്പ്" ഫംഗ്‌ഷനിലേക്കുള്ള ഒരു XS ഇന്റർഫേസാണ്.

"baseex" എന്നത് ഒരു പിശക് സന്ദേശം അല്ലെങ്കിൽ വസ്തുവാണ്. ഒരു റഫറൻസ് ആണെങ്കിൽ, അത് ഉപയോഗിക്കും
അതു പൊലെ. അല്ലാത്തപക്ഷം ഇത് ഒരു സ്ട്രിംഗായി ഉപയോഗിക്കുന്നു, കൂടാതെ അത് ഒരു പുതിയ വരിയിൽ അവസാനിക്കുന്നില്ലെങ്കിൽ
കോഡിലെ നിലവിലെ സ്ഥാനത്തിന്റെ ചില സൂചനകളോടെ അത് നീട്ടും,
"mess_sv" എന്നതിന് വിവരിച്ചത് പോലെ.

പിശക് സന്ദേശം അല്ലെങ്കിൽ ഒബ്ജക്റ്റ് സ്ഥിരസ്ഥിതിയായി സാധാരണ പിശകിലേക്ക് എഴുതപ്പെടും, പക്ഷേ ഇത്
ഒരു $SIG{__WARN__} ഹാൻഡ്‌ലറുടെ പരിഷ്‌ക്കരണത്തിന് വിധേയമാണ്.

ഒരു ലളിതമായ സ്ട്രിംഗ് സന്ദേശം ഉപയോഗിച്ച് മുന്നറിയിപ്പ് നൽകാൻ, "മുന്നറിയിപ്പ്" പ്രവർത്തനം കൂടുതൽ സൗകര്യപ്രദമായിരിക്കും.

ശൂന്യമായ warn_sv(SV *baseex)

രേഖപ്പെടുത്താത്തവ ഫംഗ്ഷനുകളും

പബ്ലിക് എപിഐയുടെ ഭാഗമായി ഇനിപ്പറയുന്ന ഫംഗ്‌ഷനുകൾ ഫ്ലാഗ് ചെയ്‌തിട്ടുണ്ട്, എന്നാൽ നിലവിൽ ഉണ്ട്
രേഖകളില്ലാത്ത. ഇന്റർഫേസുകൾ മാറ്റത്തിന് വിധേയമായതിനാൽ അവ നിങ്ങളുടെ സ്വന്തം ഉത്തരവാദിത്തത്തിൽ ഉപയോഗിക്കുക.
ഈ ഡോക്യുമെന്റിൽ ലിസ്റ്റുചെയ്തിട്ടില്ലാത്ത ഫംഗ്ഷനുകൾ പൊതു ഉപയോഗത്തിന് ഉദ്ദേശിച്ചുള്ളതല്ല, അവയും വേണം
ഒരു സാഹചര്യത്തിലും ഉപയോഗിക്കരുത്.

ചുവടെയുള്ള രേഖപ്പെടുത്താത്ത ഫംഗ്‌ഷനുകളിലൊന്ന് നിങ്ങൾ ഉപയോഗിക്കുകയാണെങ്കിൽ, സൃഷ്‌ടിക്കുന്നത് പരിഗണിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം
അതിനുള്ള ഡോക്യുമെന്റേഷൻ സമർപ്പിക്കുന്നു. നിങ്ങളുടെ പാച്ച് അംഗീകരിക്കപ്പെട്ടാൽ, ഇത് സൂചിപ്പിക്കുന്നത്
ഇന്റർഫേസ് സ്ഥിരതയുള്ളതാണ് (അത് വ്യക്തമായി അടയാളപ്പെടുത്തിയിട്ടില്ലെങ്കിൽ).

GetVars
Gv_AMഅപ്ഡേറ്റ്
PerlIO_clearrr
PerlIO_close
PerlIO_context_layers
PerlIO_eof
PerlIO_error
PerlIO_fileno
PerlIO_fill
PerlIO_flush
PerlIO_get_base
PerlIO_get_bufsiz
PerlIO_get_cnt
PerlIO_get_ptr
PerlIO_read
PerlIO_seek
PerlIO_set_cnt
PerlIO_set_ptrcnt
PerlIO_setlinebuf
PerlIO_stderr
PerlIO_stdin
PerlIO_stdout
PerlIO_tell
PerlIO_വായിക്കാത്തത്
PerlIO_write
മാജിക്_കോൾ
അമാജിക്_ഡെരെഫ്_കോൾ
ഏതെങ്കിലും_ഡ്യൂപ്പ്
atfork_lock
atfork_unlock
av_arylen_p
av_iter_p
ബ്ലോക്ക്_ഗിമ്മെ
call_atexit
കോൾ_ലിസ്റ്റ്
കാലോക്ക്
cast_i32
cast_iv
cast_ulong
cast_uv
ck_warner
ck_warner_d
ckwarn
ckwarn_d
clone_params_del
clone_params_new
ക്രോക്ക്_മെമ്മറി_റാപ്പ്
croak_nocontext
csighandler
cx_dump
cx_dup
cxinc
deb
deb_nocontext
debop
debprofdump
debstack
debstackptrs
delimcpy
ഡെസ്പാച്ച്_സിഗ്നലുകൾ
ഡൈ_നോകോൺടെക്സ്റ്റ്
dirp_dup
do_aspawn
do_binmode
do_close
do_gv_dump
do_gvgv_dump
do_hv_dump
ചേരുക
do_magic_dump
do_op_dump
തുറക്കുക
do_open9
ചെയ്യുക_തുറക്കുക
do_pmop_dump
do_spawn
do_spawn_ nowwait
do_sprintf
do_sv_dump
കളങ്കപ്പെടുത്തുന്നു
ഡോഫ്
കാറ്റുവീശുക
dowantarray
dump_eval
dump_form
ഡംപ്_ഇൻഡന്റ്
dump_mstats
dump_sub
dump_vindent
ഫിൽറ്റർ_ചേർക്കുക
ഫിൽറ്റർ_ഡെൽ
ഫിൽറ്റർ_റീഡ്
foldEQ_latin1
form_nocontext
fp_dup
fprintf_nocontext
free_global_struct
free_tmps
സന്ദർഭ_സന്ദർഭം
get_mstats
get_op_descs
നേടുക_op_names
get_ppaddr
get_vtbl
gp_dup
gp_free
gp_ref
gv_AVadd
gv_HVadd
gv_IOadd
gv_SVadd
gv_add_by_type
gv_autoload4
gv_autoload_pv
gv_autoload_pvn
gv_autoload_sv
gv_check
gv_dump
gv_efullname
gv_efullname3
gv_efullname4
gv_fetchfile
gv_fetchfile_flags
gv_fetchpv
gv_fetchpvn_flags
gv_fetchsv
gv_fullname
gv_fullname3
gv_fullname4
gv_handler
gv_name_set
അവൻ_ഡപ്പ്
ഹെക്_ഡപ്പ്
hv_common
hv_common_key_len
hv_delayfree_ent
hv_eiter_p
hv_eiter_set
hv_free_ent
hv_ksplit
hv_name_set
hv_placeholders_get
hv_placeholders_set
hv_rand_set
hv_riter_p
hv_riter_set
ibcmp_utf8
init_global_struct
init_stacks
init_tm
instr
is_lvalue_sub
ലീവ്_സ്കോപ്പ്
load_module_nocontext
മാജിക്_ഡമ്പ്
malloc
markstack_grow
mess_nocontext
mfree
mg_dup
mg_size
മിനി_mktime
കൂടുതൽ സ്വിച്ചുകൾ
mro_get_from_name
mro_get_private_data
mro_set_mro
mro_set_private_data
my_atof
my_atof2
എന്റെ_ബികോപ്പി
my_bzero
my_chsize
my_cxt_index
my_cxt_init
my_dirfd
എന്റെ_എക്സിറ്റ്
my_failure_exit
എന്റെ_ഫ്ലഷ്_എല്ലാം
എന്റെ_ഫോർക്ക്
my_lstat
my_memcmp
എന്റെ_മെംസെറ്റ്
my_pclose
എന്റെ_പോപ്പൻ
എന്റെ_പോപ്പൻ_ലിസ്റ്റ്
my_setenv
my_socketpair
my_stat
my_strftime
പുതിയ ANONATTRSUB
ന്യൂഅനോൻഹാഷ്
പുതിയ അനൺലിസ്റ്റ്
newANONSUB
പുതിയATTRSUB
പുതിയ AVREF
പുതിയCVREF
പുതിയ ഫോം
പുതിയ ജി.വി.ആർ.ഇ.എഫ്
പുതിയ ജിവിജെൻ
newGVgen_flags
പുതിയHVREF
newHVhv
newIO
പുതിയMYSUB
പുതിയPROG
newRV
newSUB
newSVREF
newSVpvf_nocontext
new_stackinfo
ninstr
op_refcnt_lock
op_refcnt_unlock
പാർസർ_ഡ്യൂപ്പ്
perl_alloc_using
perl_clone_using
pmop_dump
പോപ്പ്_സ്കോപ്പ്
pregcomp
പ്രീജെക്സെക്
പ്രീഗ്ഫ്രീ
pregfree2
printf_nocontext
ptr_table_fetch
ptr_table_free
ptr_table_new
ptr_table_split
ptr_table_store
പുഷ്_സ്കോപ്പ്
വീണ്ടും കംപൈൽ
re_dup_guts
re_intuit_start
re_intuit_string
realloc
reentrant_free
reentrant_init
reentrant_retry
reentrant_size
റഫറൻസ്
reg_named_buff_all
reg_named_buff_നിലവിൽ
reg_named_buff_fetch
reg_named_buff_firstkey
reg_named_buff_nextkey
reg_named_buff_scalar
regclass_swash
regdump
regdupe_internal
regexec_flags
regfree_ആന്തരികം
റെജിനിറ്റ് കളറുകൾ
regnext
ആവർത്തിക്കുക
rninstr
സിഗ്നൽ
rsignal_state
runops_debug
runops_standard
rvpv_dup
സുരക്ഷിതം
സുരക്ഷിതം
സുരക്ഷിതത്വം
സുരക്ഷിതം
സേവ്_I16
സേവ്_I32
സേവ്_I8
save_adelete
സേവ്_എലെം
save_aelem_flags
save_alloc
save_aptr
സേവ്_റി
save_bool
save_clearsv
save_delete
സേവ്_ഡിസ്ട്രക്റ്റർ
save_destructor_x
save_freeop
save_freepv
save_freesv
save_generic_pvref
save_generic_svref
സേവ്_ജിപി
സേവ്_ഹാഷ്
save_hdelete
സേവ്_ഹെലെം
സേവ്_ഹെലെം_ഫ്ലാഗുകൾ
സൂചകങ്ങൾ സംരക്ഷിക്കുക
save_hptr
സേവ്_ഇന്റ്
സേവ്_ഇനം
സേവ്_iv
സേവ്_ലിസ്റ്റ്
സംരക്ഷിക്കുക
save_mortalizesv
save_nogv
save_op
save_padsv_and_mortalize
save_pptr
save_pushi32ptr
save_pushptr
save_pushptrptr
save_re_context
സേവ്_സ്കെലാർ
save_set_svflags
save_shared_pvref
save_sptr
save_svref
save_vptr
savestack_grow
savestack_grow_cnt
സ്കാൻ_എണ്ണം
സ്കാൻ_വിസ്ട്രിംഗ്
വിത്തുവീതം
സെറ്റ്_സന്ദർഭം
set_numeric_local
set_numeric_radix
set_numeric_standard
share_hek
si_dup
ss_dup
സ്റ്റാക്ക്_ഗ്രോ
ആരംഭിക്കുക_സബ്പാർസ്
str_to_version
sv_2iv
sv_2pv
sv_2uv
sv_catpvf_mg_nocontext
sv_catpvf_nocontext
sv_dup
sv_dup_inc
sv_peek
sv_pvn_nomg
sv_setpvf_mg_nocontext
sv_setpvf_nocontext
സ്വാഷ്_ഫെച്ച്
swash_init
sys_init
sys_init3
sys_intern_clear
sys_intern_dup
sys_intern_init
sys_term
taint_env
taint_proper
unlnk
പങ്കിടാതിരിക്കുക
utf16_to_utf8
utf16_to_utf8_reversed
uvuni_to_utf8
vdeb
vform
vload_module
vnewSVpvf
vwarner
warn_nocontext
മുന്നറിയിപ്പ്
warner_nocontext
ഏത്
whichsig_pv
whichsig_pvn
whichsig_sv

AUTHORS

1997 മെയ് വരെ, ഈ പ്രമാണം ജെഫ് ഒകമോട്ടോ പരിപാലിച്ചുokamoto@corp.hp.com>. അത്
ഇപ്പോൾ പേളിന്റെ തന്നെ ഭാഗമായി പരിപാലിക്കപ്പെടുന്നു.

ഡീൻ റോഹ്‌റിച്ച്, മാൽക്കം ബീറ്റി, ആൻഡ്രിയാസ് കൊയിനിഗ് എന്നിവരിൽ നിന്നുള്ള ധാരാളം സഹായങ്ങളും നിർദ്ദേശങ്ങളും ഉപയോഗിച്ച്,
പോൾ ഹഡ്‌സൺ, ഇല്യ സഖാരെവിച്ച്, പോൾ മാർക്വെസ്, നീൽ ബോവേഴ്‌സ്, മാത്യു ഗ്രീൻ, ടിം ബൻസ്,
സ്പൈഡർ ബോർഡ്മാൻ, അൾറിച്ച് ഫൈഫർ, സ്റ്റീഫൻ മക്കാമന്റ്, ഗുരുസാമി സാരഥി.

API ലിസ്റ്റിംഗ് യഥാർത്ഥത്തിൽ ഡീൻ റോഹ്‌റിച്ച് ആണ്roehrich@cray.com>.

ബെഞ്ചമിൻ സ്‌റ്റൂലിന്റെ ഉറവിടത്തിലെ അഭിപ്രായങ്ങളിൽ നിന്ന് സ്വയമേവ സൃഷ്‌ടിക്കാൻ അപ്‌ഡേറ്റ് ചെയ്‌തു.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് പെർലാപി ഓൺലൈനായി ഉപയോഗിക്കുക