makepp_signatures - ക്ലൗഡിൽ ഓൺലൈനായി

പട്ടിക:

NAME

makepp_signatures -- ഫയലുകൾ മാറിയപ്പോൾ makepp എങ്ങനെ അറിയും

വിവരണം

C: C,
c_compilation_md5, M: "md5", P: "പ്ലെയിൻ", S: "പങ്കിട്ട_വസ്തു", X: "xml",
xml_space

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

സിഗ്നേച്ചർ യഥാർത്ഥത്തിൽ എങ്ങനെയാണ് ഉപയോഗിക്കുന്നത് എന്നത് നിയന്ത്രിക്കുന്നത് പണിയുക ചെക്ക് രീതി (കാണുക
makepp_build_check). സാധാരണയായി, ഒരു ഫയലിന്റെ ഒപ്പ് മാറുകയാണെങ്കിൽ, ഫയൽ തന്നെ
മാറിയതായി കണക്കാക്കപ്പെടുന്നു, കൂടാതെ makepp ഒരു പുനർനിർമ്മാണത്തിന് പ്രേരിപ്പിക്കുന്നു.

makepp ഒരു ഫയൽ നിർമ്മിക്കുകയാണെങ്കിൽ, അത് അങ്ങനെ ആയിരിക്കണമെന്ന് നിങ്ങൾ കരുതുന്നില്ലെങ്കിൽ, നിങ്ങൾ പരിശോധിക്കേണ്ടതുണ്ട്
ബിൽഡ് ലോഗ് (makeplog കാണുക). ഓരോ ഫയലും എന്താണ് ചിന്തിച്ചതെന്ന് മേക്കപ്പ് ഒരു വിശദീകരണം എഴുതുന്നു
ആശ്രയിച്ചിരിക്കുന്നു, എന്തുകൊണ്ട് അത് പുനർനിർമിക്കാൻ തിരഞ്ഞെടുത്തു.

മേക്കപ്പിൽ നിരവധി സിഗ്നേച്ചർ രീതികൾ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. മേക്കപ്പ് സാധാരണയായി ഏറ്റവും കൂടുതൽ തിരഞ്ഞെടുക്കുന്നു
ഉചിതമായ സ്റ്റാൻഡേർഡ് ഒന്ന് സ്വയമേവ. എന്നിരുന്നാലും, നിങ്ങൾക്ക് ഒപ്പ് രീതി മാറ്റാം
ഫയലുകളെ ആശ്രയിക്കുന്ന റൂളിൽ ": സിഗ്നേച്ചർ" മോഡിഫയർ ഉപയോഗിച്ച് ഒരു വ്യക്തിഗത നിയമം
"സിഗ്നേച്ചർ" സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിച്ച് ഒരു മേക്ക് ഫയലിലെ എല്ലാ നിയമങ്ങളും പരിശോധിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു, അല്ലെങ്കിൽ
"-m" അല്ലെങ്കിൽ "--signature-method" കമാൻഡ് ലൈൻ ഓപ്ഷൻ ഉപയോഗിച്ച് എല്ലാ മേക്ക് ഫയലുകൾക്കും ഒരേസമയം.

Mpp::ഒപ്പ് രീതികൾ ഉൾപ്പെടുത്തിയത് in The വിതരണ
പ്ലെയിൻ (യഥാർത്ഥത്തിൽ പേരില്ലാത്ത)
ഫയലിന്റെ പരിഷ്ക്കരണ സമയവും ഫയലിന്റെ വലുപ്പവുമാണ് പ്ലെയിൻ സിഗ്നേച്ചർ രീതി,
കൂട്ടിച്ചേർത്തത്. ഈ മൂല്യങ്ങൾ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൽ നിന്നും വേഗത്തിൽ ലഭിക്കും
ഫയൽ മാറുമ്പോൾ മിക്കവാറും എപ്പോഴും മാറും. സിംലിങ്കുകൾക്ക് ഇത് മൂല്യങ്ങൾ ഉപയോഗിക്കുന്നു
ലിങ്കി. ലിങ്കി ഇല്ലെങ്കിൽ, അതായത് അതൊരു തൂങ്ങിക്കിടക്കുന്ന സിംലിങ്ക് ആണെങ്കിൽ, അത് സ്വന്തമായി ഉപയോഗിക്കുന്നു
മൂല്യങ്ങൾ, എന്നാൽ വസ്തുത അടയാളപ്പെടുത്താൻ ഒരു 0 മുൻകൂർ ചെയ്യുന്നു.

Makepp ഫയലിന്റെ പരിഷ്‌ക്കരണ സമയം മാത്രം നോക്കിയിരുന്നു, എന്നാൽ നിങ്ങൾ makepp പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ
ഒരു സെക്കൻഡിനുള്ളിൽ പല പ്രാവശ്യം (ഉദാ, ഒരു സ്‌ക്രിപ്‌റ്റിൽ നിരവധി ചെറുത്
കാര്യങ്ങൾ), ചിലപ്പോൾ പരിഷ്ക്കരണ സമയം മാറില്ല. തുടർന്ന്, ഫയലിന്റെ വലുപ്പം പ്രതീക്ഷിക്കാം
മാറും.

നിങ്ങൾ ഒരു സെക്കൻഡിൽ നിരവധി തവണ makepp പ്രവർത്തിപ്പിക്കുന്ന സാഹചര്യം നിങ്ങൾക്ക് ഒരു പ്രശ്നമാണെങ്കിൽ, നിങ്ങൾ
"md5" രീതി ഉപയോഗിക്കുന്നത് കുറച്ചുകൂടി വിശ്വസനീയമാണെന്ന് കണ്ടെത്തിയേക്കാം. മേക്കപ്പ് നിർമ്മിക്കുകയാണെങ്കിൽ എ
ഫയൽ, ഫയലിന്റെ തീയതി മാറിയിട്ടില്ലെങ്കിൽപ്പോലും അതിന്റെ കാഷെ ചെയ്ത MD5 ഒപ്പുകൾ ഫ്ലഷ് ചെയ്യുന്നു.

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

C
c_compilation_md5
കംപൈലറുകൾ പോലെയുള്ള സിയിലേക്ക് ഫയലുകൾ ഇൻപുട്ട് ചെയ്യുന്നതിനുള്ള രീതിയാണിത്. ഒരു ഫയലിന്റെ പേരുണ്ടോ എന്ന് ഇത് പരിശോധിക്കുന്നു
Corba IDL പോലുള്ളവ ഉൾപ്പെടെ, C അല്ലെങ്കിൽ C++ സോഴ്സ് കോഡ് പോലെ തോന്നുന്നു. അത് ചെയ്താൽ, ഇത്
രീതി ബാധകമാണ്. ഇല്ലെങ്കിൽ, അത് ബൈനറി ഫയലുകൾക്കുള്ള പ്ലെയിൻ സിഗ്നേച്ചറിലേക്ക് മടങ്ങും
(പേര് അല്ലെങ്കിൽ ഉള്ളടക്കം അനുസരിച്ച് നിർണ്ണയിക്കുന്നത്) കൂടാതെ "md5" ലേക്ക്.

ഫോർമാറ്റിംഗ് മാറ്റങ്ങളിൽ നിന്ന് സ്വതന്ത്രമായിരിക്കുക എന്നതാണ് ആശയം. വലിച്ചാണ് ഇത് ചെയ്യുന്നത്
സാധ്യമായിടത്തോളം എല്ലാം ഉയർത്തി, അപ്രധാനമായ ഇടങ്ങൾ ഒഴിവാക്കിക്കൊണ്ട്. വാക്കുകളാണ്
മുകളിലേക്ക് വലിക്കുന്നതിൽ നിന്ന് ഒഴിവാക്കിയിരിക്കുന്നു, കാരണം അവ "__LINE__" അടങ്ങിയ മാക്രോകളായിരിക്കാം, അതിനാൽ അവ
അവർ ഉണ്ടായിരുന്ന വരിയിൽ തന്നെ തുടരുക.

// അഭിപ്രായം അവഗണിച്ചു

#ifdef XYZ
#ഉൾപ്പെടുന്നു
#അവസാനം

int a = 1;

#ലൈൻ 20
ശൂന്യമായ f
(
ഇൻറ്റ് ബി
)
{
a += b + ++c;
}

/* കൂടുതൽ അവഗണിക്കപ്പെട്ട അഭിപ്രായം */

അത് പോലെയാണ് പരിഗണിക്കുന്നത്

#ifdef XYZ
#ഉൾപ്പെടുന്നു
#അവസാനം

int a=1;
#ലൈൻ 20
ശൂന്യമായ f(

int b){

a+=b+ ++c;}

അതുവഴി നിങ്ങളുടെ കോഡ് റീഇൻഡന്റ് ചെയ്യാനോ ഒരു ട്രിഗർ ചെയ്യാതെ തന്നെ കമന്റുകൾ ചേർക്കാനോ മാറ്റാനോ കഴിയും
നിങ്ങൾ ലൈൻ നമ്പറുകൾ മാറ്റാത്തിടത്തോളം കാലം പുനർനിർമ്മിക്കുക. (ഈ സിഗ്നേച്ചർ രീതി
"__LINE__" എന്നതിലേക്കുള്ള കോളുകൾക്ക് കാരണമാകുന്നതിനാൽ ലൈൻ നമ്പറുകൾ മാറിയിട്ടുണ്ടെങ്കിൽ വീണ്ടും കംപൈൽ ചെയ്യുന്നു
മാറ്റാനുള്ള മിക്ക ഡീബഗ്ഗിംഗ് വിവരങ്ങളും.) ഇത് വൈറ്റ്‌സ്‌പെയ്‌സും അഭിപ്രായങ്ങളും അവഗണിക്കുന്നു ശേഷം
അവസാന ടോക്കൺ. നിങ്ങളുടെ VC വരികൾ ചേർക്കുകയാണെങ്കിൽ ഉപയോഗശൂന്യമായ പുനർനിർമ്മാണം തടയാൻ ഇത് ഉപയോഗപ്രദമാണ്
ചെക്ക് ഇൻ ചെയ്യുമ്പോൾ "$""ലോഗ്$" ടാഗിൽ.

ഇനിപ്പറയുന്ന സാഹചര്യങ്ങളിൽ ഈ രീതി പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്:

· സാധാരണയായി ഉൾപ്പെടുത്തിയിരിക്കുന്ന ഒരു തലക്കെട്ട് ഫയലിലെ അഭിപ്രായങ്ങളിൽ നിങ്ങൾ മാറ്റങ്ങൾ വരുത്താൻ ആഗ്രഹിക്കുന്നു, അല്ലെങ്കിൽ
നിങ്ങൾക്ക് അതിന്റെ ഒരു ഭാഗം ഫോർമാറ്റ് ചെയ്യാനോ റീഇൻഡന്റ് ചെയ്യാനോ താൽപ്പര്യമുണ്ട്. ഞാൻ പ്രവർത്തിച്ച ഒരു പ്രോജക്റ്റിനായി എ
വളരെക്കാലം മുമ്പ്, പൊതുവായുള്ള തെറ്റായ അഭിപ്രായങ്ങൾ തിരുത്താൻ ഞങ്ങൾ തയ്യാറായില്ല
ഹെഡർ ഫയൽ, അവർ ഗൗരവമായി തെറ്റിദ്ധരിപ്പിക്കുമ്പോൾ പോലും, അങ്ങനെ ചെയ്യുന്നത് അങ്ങനെ ചെയ്യും
നിരവധി മണിക്കൂർ പുനർനിർമ്മിക്കാൻ ട്രിഗർ. ഈ സിഗ്നേച്ചർ രീതി ഉപയോഗിച്ച്, ഇത് മേലിൽ ഇല്ല
ഒരു പ്രശ്നം.

· നിങ്ങളുടെ ഫയലുകൾ ഇടയ്ക്കിടെ സേവ് ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു, നിങ്ങളുടെ എഡിറ്റർ (ഇമാക്സിൽ നിന്ന് വ്യത്യസ്തമായി) സന്തോഷത്തോടെ ചെയ്യും
ഒന്നും മാറിയിട്ടില്ലെങ്കിലും ഒരു പുതിയ പകർപ്പ് എഴുതുക.

· നിങ്ങൾക്ക് C/C++ ഉറവിട ഫയലുകൾ ഉണ്ട്, അവ മറ്റ് ബിൽഡ് വഴി സ്വയമേവ ജനറേറ്റ് ചെയ്യുന്നു
കമാൻഡുകൾ (ഉദാ, yacc അല്ലെങ്കിൽ മറ്റേതെങ്കിലും പ്രീപ്രൊസസ്സർ). ഞാൻ പ്രവർത്തിക്കുന്ന ഒരു സിസ്റ്റത്തിനായി, ഞങ്ങൾ
(yacc പോലെ) രണ്ട് ഔട്ട്‌പുട്ട് ഫയലുകൾ നിർമ്മിക്കുന്ന ഒരു പ്രീപ്രൊസസ്സർ ഉണ്ടായിരിക്കുക, ഒരു ".cxx", a
".h" ഫയൽ:

%.h %.cxx: %.qtdlg $(HLIB)/Qt/qt_dialog_generator
$(HLIB)/Qt/qt_dialog_generator $(ഇൻപുട്ട്)

ഇൻപുട്ട് ഫയൽ മാറുമ്പോഴെല്ലാം, ഫലം .h ഫയലും മാറ്റിയെഴുതി, ഒപ്പം
സാധാരണഗതിയിൽ, ഇത് ഉൾപ്പെടുന്ന എല്ലാറ്റിന്റെയും പുനർനിർമ്മാണത്തിന് ഇത് കാരണമാകും. എന്നിരുന്നാലും,
മിക്ക സമയത്തും ഉള്ളടക്കം .h ഫയൽ യഥാർത്ഥത്തിൽ മാറിയിട്ടില്ല (എ ഒഴികെ
പ്രിപ്രൊസസ്സർ എഴുതിയ ബിൽഡ് സമയത്തെക്കുറിച്ച് അഭിപ്രായം), അങ്ങനെ ഒരു പുനഃസംയോജനം ആയിരുന്നു
യഥാർത്ഥത്തിൽ ആവശ്യമില്ല.

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

വികസന സമയത്ത് നിങ്ങൾക്ക് തെറ്റായ ലൈൻ നമ്പറുകളിൽ ജീവിക്കാൻ കഴിയുമെങ്കിൽ, നിങ്ങൾക്ക് വേരിയബിൾ സജ്ജമാക്കാൻ കഴിയും
"makepp_signature_C_flat" (ഒരു വലിയക്ഷരം C ഉള്ളത്) ചില യഥാർത്ഥ മൂല്യത്തിലേക്ക് (1 പോലെ). പിന്നെ,
കംപൈലർ ഇപ്പോഴും യഥാർത്ഥ ഫയൽ കാണുമ്പോൾ, മുകളിലുള്ള ഉദാഹരണം പരന്നതായിരിക്കും
ഒപ്പിടുന്നത്:

#ifdef XYZ
#ഉൾപ്പെടുന്നു
#അവസാനം
int a=1;void f(int b){a+=b+ ++c;}

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

വിപരീതവും ശരിയാണ്: ഈ ഓപ്ഷൻ സജ്ജീകരിച്ച് വീണ്ടും കംപൈൽ ചെയ്തതിന് ശേഷം ഒഴിവാക്കുക
നിങ്ങളുടെ ലൈൻ നമ്പറുകൾ ശരിയാക്കില്ല. അതിനാൽ, ലൈൻ നമ്പറുകൾ പ്രധാനമാണെങ്കിൽ, ഒരു പ്രൊഡക്ഷൻ ചെയ്യരുത്
ആദ്യം വൃത്തിയാക്കാതെ അതേ സാൻഡ്ബോക്സിൽ നിർമ്മിക്കുക.

md5 "C" രീതി തിരിച്ചറിയാത്ത ഫയലുകൾക്കുള്ള ഡിഫോൾട്ട് രീതിയാണിത്. കണക്കുകൂട്ടുന്നു ഒരു
ഫയലിന്റെ തീയതിയോ വലുപ്പമോ നോക്കുന്നതിനുപകരം, ഫയലിന്റെ ഉള്ളടക്കത്തിന്റെ MD5 ചെക്ക്സം.
ഇതിനർത്ഥം നിങ്ങൾ ഫയലിലെ തീയതി മാറ്റുകയും അതിലെ ഉള്ളടക്കം മാറ്റാതിരിക്കുകയും ചെയ്താൽ,
makepp അതിനെ ആശ്രയിക്കുന്ന ഒന്നും പുനർനിർമ്മിക്കാൻ ശ്രമിക്കില്ല.

നിങ്ങളുടെ പക്കൽ പലപ്പോഴും പുനരുജ്ജീവിപ്പിക്കുന്ന ചില ഫയൽ ഉണ്ടെങ്കിൽ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്
മറ്റ് ഫയലുകൾ ആശ്രയിക്കുന്ന ബിൽഡ് പ്രോസസ്സ്, എന്നാൽ ഇത് സാധാരണയായി അല്ല
മാറ്റം. നിങ്ങൾ "md5" സിഗ്നേച്ചർ ചെക്കിംഗ് രീതി ഉപയോഗിക്കുകയാണെങ്കിൽ, makepp അത് മനസ്സിലാക്കും
ഫയലിന്റെ തീയതി മാറിയിട്ടുണ്ടെങ്കിലും ഫയലിന്റെ ഉള്ളടക്കം മാറിയിട്ടില്ല. (തീർച്ചയായും, ഇത്
ആർക്കൈവ് ഫയലുകൾ ചെയ്യുന്നതുപോലെ, ഫയലുകൾക്കുള്ളിൽ ടൈംസ്റ്റാമ്പ് എഴുതിയിട്ടുണ്ടെങ്കിൽ അത് സഹായിക്കില്ല
ഉദാഹരണത്തിന്.)

പങ്കിട്ട_വസ്തു
നിങ്ങളുടെ പാതയിൽ "nm" എന്ന യൂട്ടിലിറ്റി ഉണ്ടെങ്കിൽ മാത്രമേ ഈ രീതി പ്രവർത്തിക്കൂ, അത് അംഗീകരിക്കുന്നു
Posix ഫോർമാറ്റ് ഔട്ട്പുട്ട് ചെയ്യാനുള്ള "-P" ഓപ്ഷൻ. അങ്ങനെയെങ്കിൽ, ചിഹ്നങ്ങളുടെ പേരുകളും തരങ്ങളും മാത്രം
ചലനാത്മകമായി ലോഡുചെയ്‌ത ലൈബ്രറികളിൽ അവയുടെ ഒപ്പിന്റെ ഭാഗമാകും. ഫലം അതാണ്
ഉപയോഗിക്കുന്ന പ്രോഗ്രാമുകൾ വീണ്ടും ലിങ്ക് ചെയ്യാതെ തന്നെ നിങ്ങൾക്ക് ഫംഗ്‌ഷനുകളുടെ കോഡിംഗ് മാറ്റാൻ കഴിയും
അവരെ.

ഇനിപ്പറയുന്ന കമാൻഡിൽ പാർസർ ഒരു പരോക്ഷമായ ആശ്രിതത്വം കണ്ടെത്തും
$(LIBDIR)/libmylib.so, ആവശ്യമെങ്കിൽ അത് നിർമ്മിക്കുക. എന്നിരുന്നാലും ലിങ്ക് കമാൻഡ് മാത്രമായിരിക്കും
ലൈബ്രറി വ്യത്യസ്‌തമായ ചിഹ്നങ്ങൾ എക്‌സ്‌പോർട്ടുചെയ്യുമ്പോഴെല്ലാം പുനർനിർമ്മിക്കുക:

myprog: $(OBJECTS) : ഒപ്പ് share_object
$(LD) -L$(LIBDIR) -lmylib $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്‌പുട്ട്)

ഫംഗ്‌ഷനുകളുടെ ഇന്റർഫേസുകൾ മാറാത്തിടത്തോളം ഇത് പ്രവർത്തിക്കുന്നു. എന്നാൽ ആ സാഹചര്യത്തിൽ നിങ്ങൾ
പ്രഖ്യാപനം മാറ്റുക, അതിനാൽ നിങ്ങൾ വിളിക്കുന്നവരെയും മാറ്റേണ്ടതുണ്ട്.

ഈ രീതി ഒരു പങ്കിട്ട ലൈബ്രറി പോലെയുള്ള ഫയലുകൾക്ക് മാത്രമേ ബാധകമാകൂ എന്നത് ശ്രദ്ധിക്കുക.
മറ്റെല്ലാ ഫയലുകൾക്കും ഇത് "c_compilation_md5" എന്നതിലേക്ക് മടങ്ങുന്നു, അത് പിന്നോട്ട് പോയേക്കാം
മറ്റുള്ളവർക്ക്.

XML
xml_space
xml കാനോനികമായി കൈകാര്യം ചെയ്യുന്നതും അവയിൽ മാത്രം വ്യത്യാസമുള്ളതുമായ രണ്ട് സമാന രീതികളാണിത്
വൈറ്റ്‌സ്‌പേസ് കൈകാര്യം ചെയ്യൽ. ആദ്യത്തേത് ടാഗുകൾക്ക് ചുറ്റും അത് പൂർണ്ണമായും അവഗണിക്കുകയും അത് പരിഗണിക്കുകയും ചെയ്യുന്നു
മറ്റൊരിടത്ത് ഒരൊറ്റ ഇടം പോലെ, ഫോർമാറ്റിംഗ് മാറ്റങ്ങളിൽ നിന്ന് ഒപ്പിനെ പ്രതിരോധിക്കും. ദി
രണ്ടാമത് xml-ലെ ഏതെങ്കിലും വൈറ്റ്‌സ്‌പെയ്‌സിനെ മാനിക്കുന്നു, അത് ചെറുതാണെങ്കിൽ പോലും ആവശ്യമാണ്
ഒരു ഭാഗം പോലെ " "ഒരു xhtml പ്രമാണത്തിലെ വിഭാഗം.

ഓരോ xml ഡോക്യുമെന്റിന്റെയും സാരാംശത്തിൽ ഒപ്പിടുന്നു എന്നതാണ് രണ്ട് രീതികൾക്കും പൊതുവായത്. സാന്നിധ്യം
അല്ലെങ്കിൽ ഒരു BOM ന്റെ അല്ലെങ്കിൽ " "ഹെഡർ അവഗണിച്ചു. അഭിപ്രായങ്ങൾ അവഗണിക്കപ്പെട്ടു
ടെക്സ്റ്റ് "CDATA" അല്ലെങ്കിൽ എന്റിറ്റികൾ ഉപയോഗിച്ച് പരിരക്ഷിച്ചിരിക്കുന്നു. ആട്രിബ്യൂട്ടുകളുടെ ക്രമവും ഉദ്ധരണി ശൈലിയും
ശൂന്യമായ ടാഗുകൾ നിങ്ങൾ എങ്ങനെ റെൻഡർ ചെയ്യുന്നു എന്നതും പ്രശ്നമല്ല.

സാധുവായ xml അല്ലാത്ത ഏതെങ്കിലും ഫയലിന്, അല്ലെങ്കിൽ Expat അടിസ്ഥാനമാക്കിയുള്ള "XML::Parser" അല്ലെങ്കിൽ
"XML::LibXML" പാർസർ ഇൻസ്റ്റാൾ ചെയ്തിട്ടില്ല, ഇത് md5 രീതിയിലേക്ക് മടങ്ങുന്നു. നിങ്ങൾ മാറുകയാണെങ്കിൽ
നിങ്ങളുടെ പേൾ ഇൻസ്റ്റാളേഷൻ പാഴ്‌സറുകളിലൊന്നിൽ നിന്ന് മറ്റുള്ളവയിലേക്ക്, makepp ചിന്തിക്കും
ടൈംസ്റ്റാമ്പ് മാറുമ്പോൾ ഫയലുകൾ വ്യത്യസ്തമായിരിക്കും. ഇതിന്റെ ഫലമാണ് കാരണം
ഒന്നുകിൽ പാഴ്സർ യുക്തിപരമായി തുല്യമാണ്, പക്ഷേ അവ വ്യത്യസ്ത ഒപ്പുകൾ സൃഷ്ടിക്കുന്നു. ൽ
ഇത് ഒരു പ്രശ്നമാകാൻ സാധ്യതയില്ല, നിങ്ങൾക്ക് "XML::LibXML" എന്നതിന്റെ ഉപയോഗം നിർബന്ധമാക്കാം
Perl-ൽ ക്രമീകരണം:

$Mpp:: ഒപ്പ്::xml::libxml = 1;

വിപുലീകരിക്കുന്നു പ്രയോഗക്ഷമത
"C" അല്ലെങ്കിൽ "c_compilation_md5" രീതിക്ക് അത് തിരിച്ചറിയുന്ന പ്രത്യയങ്ങളുടെ ഒരു ബിൽറ്റ്-ഇൻ ലിസ്റ്റ് ഉണ്ട്
സി അല്ലെങ്കിൽ സി പോലെയാണ്. ഇത് മറ്റ് ഫയലുകളിൽ പ്രയോഗിച്ചാൽ അത് ലളിതമായ ഒപ്പിലേക്ക് മടങ്ങും
രീതികൾ. എന്നാൽ പല ഫയൽ തരങ്ങളും വാക്യഘടനാപരമായി ഈ രീതിക്ക് C++ ന് അടുത്താണ്
ഉപയോഗപ്രദമായ. വേണ്ടത്ര അടയ്ക്കുക എന്നതിനർത്ഥം C++ കമന്റും സ്ട്രിംഗ് വാക്യഘടനയും വൈറ്റ്‌സ്‌പെയ്‌സും അർത്ഥശൂന്യമാണ്
വാക്കുകൾക്കിടയിലുള്ള ഒരു സ്പേസ് ഒഴികെ (ഒപ്പം C++ ന്റെ പ്രശ്ന കേസുകൾ "- -", "+ +", "/ *", "< <").

ഇത് (അതിന്റെ ഉപവിഭാഗങ്ങൾ) ഇപ്പോൾ എളുപ്പത്തിൽ മറ്റ് പ്രത്യയങ്ങളിലേക്ക് വിപുലീകരിക്കാൻ കഴിയും. നിങ്ങൾക്ക് കഴിയുന്ന എവിടെയും
ഒരു സിഗ്നേച്ചർ വ്യക്തമാക്കുക
അധിക ഫയൽനാമങ്ങൾ സ്വീകരിക്കുക:

C.suffix1,suffix2,suffix3
ഒന്നോ അതിലധികമോ കോമയാൽ വേർതിരിച്ച സഫിക്സുകൾ ഒരു കോളൻ ഉപയോഗിച്ച് രീതിയിലേക്ക് ചേർക്കാം. വേണ്ടി
ഉദാഹരണം "C.ipp,tpp" എന്നതിനർത്ഥം ബിൽറ്റ് ഇൻ സഫിക്സുകൾക്ക് പുറമെ ഇത് ബാധകമാകും എന്നാണ്.
ഫയലുകൾ അവസാനിക്കുന്നു .ipp or .tpp, നിങ്ങൾ ഇൻലൈനിനും ടെംപ്ലേറ്റിനും ഉപയോഗിച്ചേക്കാം
C++ തലക്കെട്ടുകളുടെ ഭാഗം.

സി.(പ്രത്യയം-regexp)
ഇത് മുമ്പത്തേത് പോലെയാണ്, എന്നാൽ സഫിക്സുകൾ എണ്ണുന്നതിന് പകരം നിങ്ങൾ ഒരു പേർൽ നൽകുന്നു
നിങ്ങൾ ആഗ്രഹിക്കുന്നവയുമായി പൊരുത്തപ്പെടുന്നതിന് റെഗുലർ എക്സ്പ്രഷൻ. മുമ്പത്തെ ഉദാഹരണം ആയിരിക്കും
ഈ വാക്യഘടനയിൽ "C.(ipp|tpp)" അല്ലെങ്കിൽ "C.([it]pp)".

C(regexp)
ഒരു ഡോട്ട് കൂടാതെ, പേൾ റെഗുലർ എക്സ്പ്രഷൻ ഫയലിന്റെ പേരിൽ എവിടെയും പൊരുത്തപ്പെടുത്താനാകും. എങ്കിൽ
ഒരു സ്ലാഷ് ഉൾപ്പെടുന്നു, അത് പൂർണ്ണ യോഗ്യതയുള്ള ഫയൽ നാമത്തിന് എതിരായി ശ്രമിക്കും, അല്ലാത്തപക്ഷം
ഡയറക്‌ടറി ഇല്ലാതെ അവസാന ഭാഗത്തിന് എതിരായി മാത്രം. അതിനാൽ നിങ്ങൾക്ക് C++ ശൈലി ഉണ്ടെങ്കിൽ
ഒരു ഡയറക്‌ടറിയിലെ പ്രത്യയങ്ങളില്ലാത്ത തലക്കെട്ടുകൾ ഉൾപ്പെടുന്നു, നിങ്ങളുടെ ഒപ്പ് രീതിയായി "C(include/)" ഉപയോഗിക്കുക.
എന്നിരുന്നാലും മുകളിലുള്ള പ്രത്യയ ഉദാഹരണം ഈ രീതിയിൽ വളരെ മോശമായിരിക്കും, "C(\.(?:ipp|tpp)$$)"
അല്ലെങ്കിൽ "C(\.[it]pp$$)" കാരണം "$" എന്നത് മേക്ക് ഫയലുകളിലെ വിപുലീകരണ പ്രതീകമാണ്.

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

ഭാവിയിൽ സിഗ്നേച്ചർ രീതി കോൺഫിഗറേഷൻ ഫയൽനാമം-പാറ്റേൺ ആയി മാറ്റിയേക്കാം,
ഓപ്ഷണലായി ഓരോ കമാൻഡിനും.

കസ്റ്റം രീതികൾ
നിങ്ങൾക്ക് വേണമെങ്കിൽ, ഫയൽ ഒപ്പുകൾ കണക്കാക്കുന്നതിനുള്ള നിങ്ങളുടെ സ്വന്തം രീതികൾ നിർവചിക്കാം
അവരെ താരതമ്യം ചെയ്യുന്നു. ഇത് ചെയ്യുന്നതിന് നിങ്ങൾ ഒരു Perl മൊഡ്യൂൾ എഴുതേണ്ടതുണ്ട്. ഒന്നു നോക്കൂ
വിതരണത്തിലെ "Mpp/Signature.pm" എന്നതിലും നിലവിലുള്ള ഒപ്പിലും അഭിപ്രായങ്ങൾ
വിശദാംശങ്ങൾക്ക് "Mpp/Signature/*.pm" എന്നതിലെ അൽഗോരിതം.

നിങ്ങൾക്ക് ഒരു ഇഷ്‌ടാനുസൃത സിഗ്നേച്ചർ രീതി ആവശ്യമുള്ള ചില സന്ദർഭങ്ങൾ ഇതാ:

· ഒരു ഫയലിലെ എല്ലാ മാറ്റങ്ങളും അവഗണിക്കണമെന്ന് നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ. നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും വേണമെന്ന് പറയുക dateStamp.o ലേക്ക്
ഒരു ആശ്രിതത്വം ആകുക (പുനർനിർമ്മാണത്തിന് നിർബന്ധിക്കുക), എന്നാൽ പുനർനിർമ്മിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ല
dateStamp.o മാറ്റി. പാരമ്പര്യമായി ലഭിക്കുന്ന ഒരു സിഗ്നേച്ചർ രീതി നിങ്ങൾക്ക് നിർവചിക്കാം
"c_compilation_md5" അത് തിരിച്ചറിയുന്നു dateStamp.o അതിന്റെ പേരിൽ ഫയൽ ചെയ്യുക, എപ്പോഴും
ആ ഫയലിനായി സ്ഥിരമായ ഒരു മൂല്യം നൽകുന്നു.

· നിങ്ങൾക്ക് ഒരു ഫയലിന്റെ ഭാഗം അവഗണിക്കണമെങ്കിൽ. നിങ്ങൾക്ക് അതിനുള്ള ഒരു പ്രോഗ്രാം ഉണ്ടെന്ന് കരുതുക
ഒരു തീയതി സ്റ്റാമ്പ് ഉള്ള ഒരു ഫയൽ ജനറേറ്റ് ചെയ്യുന്നു, എന്നാൽ നിങ്ങൾ വീണ്ടും കംപൈൽ ചെയ്യാൻ ആഗ്രഹിക്കുന്നില്ല
തീയതി സ്റ്റാമ്പ് മാറി. സമാനമായ ഒരു സിഗ്നേച്ചർ രീതി നിർവ്വചിക്കുക
"c_compilation_md5" നിങ്ങളുടെ ഫയൽ ഫോർമാറ്റ് മനസ്സിലാക്കുകയും നിങ്ങൾ ചെയ്യാത്ത ഭാഗങ്ങൾ ഒഴിവാക്കുകയും ചെയ്യുന്നു
കണക്കിലെടുക്കാൻ ആഗ്രഹിക്കുന്നു.

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