perlhacktut - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

perlhacktut - ഒരു ലളിതമായ സി കോഡ് പാച്ച് സൃഷ്ടിക്കുന്നതിലൂടെ നടക്കുക

വിവരണം

ഈ പ്രമാണം നിങ്ങളെ ഒരു ലളിതമായ പാച്ച് ഉദാഹരണത്തിലൂടെ കൊണ്ടുപോകുന്നു.

നിങ്ങൾ ഇതുവരെ perlhack വായിച്ചിട്ടില്ലെങ്കിൽ, ആദ്യം അത് ചെയ്യുക! നിങ്ങൾക്ക് വായിക്കാനും താൽപ്പര്യമുണ്ടാകാം
perlsource കൂടി.

നിങ്ങൾ ഇവിടെ ചെയ്തുകഴിഞ്ഞാൽ, അടുത്തതായി perlhacktips പരിശോധിക്കുക.

ഉദാഹരണം OF A SIMPLE പാച്ച്

തുടക്കം മുതൽ അവസാനം വരെ നമുക്ക് ഒരു ലളിതമായ പാച്ച് എടുക്കാം.

ലാറി നിർദ്ദേശിച്ച ചിലത് ഇതാ: ഒരു "പാക്ക്" സമയത്ത് ഒരു "U" ആണ് ആദ്യത്തെ സജീവ ഫോർമാറ്റ് എങ്കിൽ,
(ഉദാഹരണത്തിന്, "പാക്ക് "U3C8", @stuff") അപ്പോൾ ലഭിക്കുന്ന സ്ട്രിംഗ് UTF-8 ആയി കണക്കാക്കണം
എൻകോഡ് ചെയ്തത്.

നിങ്ങൾ പേൾ റിപ്പോസിറ്ററിയുടെ ഒരു ജിറ്റ് ക്ലോൺ ഉപയോഗിച്ചാണ് പ്രവർത്തിക്കുന്നതെങ്കിൽ, നിങ്ങൾ ഒരു സൃഷ്ടിക്കാൻ ആഗ്രഹിക്കും
നിങ്ങളുടെ മാറ്റങ്ങൾക്കായി ശാഖ. ഇത് ശരിയായ പാച്ച് സൃഷ്ടിക്കുന്നത് വളരെ ലളിതമാക്കും. കാണുക
ഇത് എങ്ങനെ ചെയ്യാം എന്നതിനെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾക്ക് perlgit.

എഴുത്തു The പാച്ച്
ഇത് പരിഹരിക്കാൻ ഞങ്ങൾ എങ്ങനെ തയ്യാറെടുക്കും? ആദ്യം നമ്മൾ സംശയാസ്പദമായ കോഡ് കണ്ടെത്തുന്നു - "പാക്ക്"
റൺടൈമിൽ സംഭവിക്കുന്നു, അതിനാൽ ഇത് ഒന്നിൽ ആയിരിക്കും pp ഫയലുകൾ. തീർച്ചയായും, "pp_pack" ആണ്
in pp.c. ഞങ്ങൾ ഈ ഫയൽ മാറ്റാൻ പോകുന്നതിനാൽ, നമുക്ക് ഇത് പകർത്താം pp.c~.

[ശരി, അത് അകത്തായിരുന്നു pp.c ഈ ട്യൂട്ടോറിയൽ എഴുതിയപ്പോൾ. ഇത് ഇപ്പോൾ വിഭജിക്കപ്പെട്ടിരിക്കുന്നു
"pp_unpack" അതിന്റെ സ്വന്തം ഫയലിലേക്ക്, pp_pack.c]

ഇനി നമുക്ക് "pp_pack" നോക്കാം: "pat" എന്നതിലേക്ക് ഒരു പാറ്റേൺ എടുക്കുക, തുടർന്ന് ലൂപ്പ് ചെയ്യുക
പാറ്റേൺ, ഓരോ ഫോർമാറ്റ് പ്രതീകവും "datum_type" ആക്കി മാറ്റുന്നു. അപ്പോൾ സാധ്യമായ ഓരോന്നിനും
ഫോർമാറ്റ് പ്രതീകം, പാറ്റേണിലെ മറ്റ് ആർഗ്യുമെന്റുകൾ ഞങ്ങൾ വിഴുങ്ങുന്നു (ഒരു ഫീൽഡ് വീതി, an
നക്ഷത്രചിഹ്നം, മുതലായവ) കൂടാതെ അടുത്ത ചങ്ക് ഇൻപുട്ട് നിർദ്ദിഷ്ട ഫോർമാറ്റിലേക്ക് പരിവർത്തനം ചെയ്യുക, അത് ചേർക്കുക
ഔട്ട്പുട്ട് എസ്വി "കാറ്റ്" ലേക്ക്.

"U" ആണ് "pat" ലെ ആദ്യ ഫോർമാറ്റ് എന്ന് നമുക്ക് എങ്ങനെ അറിയാം? ശരി, നമുക്ക് ഒരു പോയിന്റർ ഉണ്ടെങ്കിൽ
"പാറ്റ്" എന്നതിന്റെ ആരംഭം, ഒരു "U" കാണുകയാണെങ്കിൽ, നമ്മൾ ഇപ്പോഴും അതിന്റെ തുടക്കത്തിലാണോ എന്ന് പരിശോധിക്കാം
ചരട്. അതിനാൽ, ഇവിടെയാണ് "പാറ്റ്" സജ്ജീകരിച്ചിരിക്കുന്നത്:

STRLEN ഫ്രൊലെൻ;
char *pat = SvPVx(*++MARK, fromlen);
ചാർ *പേറ്റൻഡ് = പാറ്റ് + ഫ്രംലെൻ;
I32 ലെൻ;
I32 ഡാറ്റ ടൈപ്പ്;
SV *fromstr;

ഞങ്ങൾക്ക് അവിടെ മറ്റൊരു സ്ട്രിംഗ് പോയിന്റർ ഉണ്ടാകും:

STRLEN ഫ്രൊലെൻ;
char *pat = SvPVx(*++MARK, fromlen);
ചാർ *പേറ്റൻഡ് = പാറ്റ് + ഫ്രംലെൻ;
+ ചാർ * പാറ്റ്‌കോപ്പി;
I32 ലെൻ;
I32 ഡാറ്റ ടൈപ്പ്;
SV *fromstr;

ഞങ്ങൾ ലൂപ്പ് ആരംഭിക്കുന്നതിന് തൊട്ടുമുമ്പ്, "പാറ്റ്" ന്റെ തുടക്കമായി ഞങ്ങൾ "പാറ്റ്കോപ്പി" സജ്ജീകരിക്കും:

ഇനങ്ങൾ = എസ്പി - മാർക്ക്;
മാർക്ക്++;
sv_setpvn(പൂച്ച, "", 0);
+ പാറ്റ് കോപ്പി = പാറ്റ്;
അതേസമയം (പാറ്റ് < പേറ്റന്റ്) {

സ്ട്രിംഗിന്റെ തുടക്കത്തിൽ ഒരു "U" കാണുകയാണെങ്കിൽ, നമ്മൾ "UTF8" ഫ്ലാഗ് ഓണാക്കും.
ഔട്ട്പുട്ട് എസ്വി, "കാറ്റ്":

+ എങ്കിൽ (datumtype == 'U' && pat==patcopy+1)
+ SvUTF8_on(പൂച്ച);
എങ്കിൽ (datumtype == '#') {
അതേസമയം (pat <patend && *pat != '\n')
പാറ്റ്++;

സ്‌ട്രിംഗിന്റെ ആദ്യ പ്രതീകമായതിനാൽ അത് "patcopy+1" ആയിരിക്കണമെന്ന് ഓർമ്മിക്കുക
"Datumtype!" ആയി വിഴുങ്ങിയ "U"

ക്ഷമിക്കണം, ഞങ്ങൾ ഒരു കാര്യം മറന്നു: പാറ്റേണിന്റെ തുടക്കത്തിൽ സ്‌പെയ്‌സുകൾ ഉണ്ടെങ്കിൽ എന്തുചെയ്യും? "പാക്ക് ("
U*", @stuff)" ആദ്യത്തെ സജീവ പ്രതീകമായി "U" ഉണ്ടായിരിക്കും, അത് ആദ്യമല്ലെങ്കിലും
പാറ്റേണിലെ കാര്യം. ഈ സാഹചര്യത്തിൽ, നമ്മൾ എപ്പോൾ "പാറ്റ്" എന്നതിനൊപ്പം "പാറ്റ്കോപ്പി" മുന്നോട്ട് കൊണ്ടുപോകണം
ഇടങ്ങൾ കാണുക:

എങ്കിൽ (isSPACE(datumtype))
തുടരുക;

ആയിത്തീരേണ്ടതുണ്ട്

എങ്കിൽ (isSPACE(datumtype)) {
പാറ്റ്കോപ്പി ++;
തുടരുക;
}

ശരി. അതാണ് സി പാർട്ട് ചെയ്തത്. ഈ പാച്ച് ആകുന്നതിന് മുമ്പ് നമ്മൾ രണ്ട് അധിക കാര്യങ്ങൾ ചെയ്യണം
പോകാൻ തയ്യാറാണ്: ഞങ്ങൾ പേളിന്റെ സ്വഭാവം മാറ്റി, അതിനാൽ ഞങ്ങൾ ആ മാറ്റം രേഖപ്പെടുത്തണം. ഞങ്ങൾ
ഞങ്ങളുടെ പാച്ച് പ്രവർത്തിക്കുന്നുണ്ടെന്നും ഇല്ലെന്നും ഉറപ്പാക്കാൻ കുറച്ച് റിഗ്രഷൻ ടെസ്റ്റുകളും നൽകണം
വരിയിൽ മറ്റെവിടെയെങ്കിലും ഒരു ബഗ് സൃഷ്ടിക്കുക.

ടെസ്റ്റിംഗ് The പാച്ച്
ഓരോ ഓപ്പറേറ്റർക്കുമുള്ള റിഗ്രഷൻ ടെസ്റ്റുകൾ തത്സമയം t/op/, അങ്ങനെ ഞങ്ങൾ ഒരു പകർപ്പ് ഉണ്ടാക്കുന്നു t/op/pack.t
ലേക്ക് t/op/pack.t~. ഇപ്പോൾ നമുക്ക് ഞങ്ങളുടെ ടെസ്റ്റുകൾ അവസാനം വരെ ചേർക്കാം. ആദ്യം, "U" ചെയ്യുന്നുണ്ടോ എന്ന് ഞങ്ങൾ പരിശോധിക്കും
തീർച്ചയായും യൂണികോഡ് സ്ട്രിംഗുകൾ സൃഷ്ടിക്കുക.

t/op/pack.t ന് വിവേകമുണ്ട് ശരി() ഫംഗ്‌ഷൻ, പക്ഷേ അത് ഇല്ലെങ്കിൽ, അതിൽ നിന്നുള്ളത് നമുക്ക് ഉപയോഗിക്കാം
t/test.pl.

'./test.pl' ആവശ്യമാണ്;
പ്ലാൻ (ടെസ്റ്റുകൾ => 159 );

അതിനാൽ ഇതിന് പകരം:

"1.20.300.4000" eq sprintf "%vd" ഒഴികെ 'അല്ല' എന്ന് അച്ചടിക്കുക,
പായ്ക്ക് ("U*",1,20,300,4000);
"ശരി $test\n" പ്രിന്റ് ചെയ്യുക; $ടെസ്റ്റ്++;

നമുക്ക് കൂടുതൽ യുക്തിസഹമായത് എഴുതാം (ഇതിന്റെ പൂർണ്ണമായ വിശദീകരണത്തിന് ടെസ്റ്റ്::കൂടുതൽ കാണുക ആണ്() മറ്റ്
ടെസ്റ്റിംഗ് പ്രവർത്തനങ്ങൾ).

ആണ്( "1.20.300.4000", sprintf "%vd", പാക്ക്("U*",1,20,300,4000),
"U* യൂണികോഡ് നിർമ്മിക്കുന്നു" );

ബിസിനസ്സ് ആരംഭിക്കുമ്പോൾ തന്നെ ഞങ്ങൾക്ക് ആ ഇടം ലഭിച്ചുവെന്ന് ഇപ്പോൾ ഞങ്ങൾ പരിശോധിക്കും:

ആണ്( "1.20.300.4000", sprintf "%vd", പാക്ക്(" U*",1,20,300,4000),
"ആരംഭത്തിൽ ഇടങ്ങളോടെ" );

അവസാനം "U" ആണെങ്കിൽ ഞങ്ങൾ യൂണികോഡ് സ്ട്രിംഗുകൾ ഉണ്ടാക്കില്ലെന്ന് ഞങ്ങൾ പരിശോധിക്കും അല്ല ആദ്യത്തെ സജീവമായത്
ഫോർമാറ്റ്:

isnt(v1.20.300.4000, sprintf "%vd", പാക്ക്("C0U*",1,20,300,4000),
"യു* ആദ്യം അല്ല യൂണികോഡ് അല്ല" );

മുകളിൽ ദൃശ്യമാകുന്ന ടെസ്റ്റുകളുടെ എണ്ണം മാറ്റാൻ മറക്കരുത്, അല്ലെങ്കിൽ
ഓട്ടോമേറ്റഡ് ടെസ്റ്റർ ആശയക്കുഴപ്പത്തിലാകും. ഇത് ഒന്നുകിൽ ഇതുപോലെ കാണപ്പെടും:

പ്രിന്റ് "1..156\n";

അല്ലെങ്കിൽ ഇത്:

പ്ലാൻ (ടെസ്റ്റുകൾ => 156 );

ഞങ്ങൾ ഇപ്പോൾ പേൾ കംപൈൽ ചെയ്യുകയും ടെസ്റ്റ് സ്യൂട്ടിലൂടെ പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു. ഞങ്ങളുടെ പുതിയ പരീക്ഷണങ്ങൾ വിജയിച്ചു, ഹൂറേ!

ഡോക്യുമെന്റിംഗ് The പാച്ച്
ഒടുവിൽ, ഡോക്യുമെന്റേഷൻ. പേപ്പർ വർക്ക് തീരുന്നതുവരെ ജോലി ഒരിക്കലും ചെയ്യില്ല, അതിനാൽ നമുക്ക്
ഞങ്ങൾ ഇപ്പോൾ വരുത്തിയ മാറ്റം വിവരിക്കുക. പ്രസക്തമായ സ്ഥലം പോഡ്/perlfunc.pod; വീണ്ടും, ഞങ്ങൾ
ഒരു പകർപ്പ് ഉണ്ടാക്കുക, തുടർന്ന് "പാക്ക്" എന്നതിന്റെ വിവരണത്തിൽ ഞങ്ങൾ ഈ വാചകം ചേർക്കും:

=ഇനം *

പാറ്റേൺ ഒരു C യിൽ ആരംഭിക്കുകയാണെങ്കിൽ , തത്ഫലമായുണ്ടാകുന്ന സ്ട്രിംഗ് പരിഗണിക്കും
UTF-8-എൻകോഡ് ചെയ്ത യൂണികോഡ് ആയി. നിങ്ങൾക്ക് ഒരു സ്ട്രിംഗിൽ UTF-8 എൻകോഡിംഗ് നിർബന്ധമാക്കാം
ഒരു പ്രാരംഭ സി ഉപയോഗിച്ച് , തുടർന്ന് വരുന്ന ബൈറ്റുകൾ ഇങ്ങനെ വ്യാഖ്യാനിക്കപ്പെടും
യൂണികോഡ് പ്രതീകങ്ങൾ. ഇത് സംഭവിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ലെങ്കിൽ, നിങ്ങൾക്ക് ആരംഭിക്കാം
സി ഉള്ള നിങ്ങളുടെ പാറ്റേൺ (അല്ലെങ്കിൽ മറ്റെന്തെങ്കിലും) UTF-0-ലേക്ക് Perl-നെ നിർബന്ധിക്കരുത്
നിങ്ങളുടെ സ്ട്രിംഗ് എൻകോഡ് ചെയ്യുക, തുടർന്ന് ഇത് C ഉപയോഗിച്ച് പിന്തുടരുക നിങ്ങളുടെ എവിടെയോ
പാറ്റേൺ.

സമർപ്പിക്കുക
ഈ പാച്ച് എങ്ങനെ സമർപ്പിക്കാം എന്നതിനെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾക്ക് perlhack കാണുക.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് perlhacktut ഓൺലൈനായി ഉപയോഗിക്കുക