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

പട്ടിക:

NAME

makepp_extending -- പേൾ ഉപയോഗിച്ച് മേക്കപ്പ് എങ്ങനെ നീട്ടാം

വിവരണം

മേക്കപ്പ് ആന്തരികമായി വേണ്ടത്ര വഴക്കമുള്ളതാണ്, അതിനാൽ കുറച്ച് പേൾ കോഡ് എഴുതുന്നതിലൂടെ നിങ്ങൾക്ക് കഴിയും
ഫംഗ്ഷനുകൾ ചേർക്കുക അല്ലെങ്കിൽ മറ്റ് നിരവധി പ്രവർത്തനങ്ങൾ ചെയ്യുക.

പൊതുവായ കുറിപ്പുകൾ on എഴുത്തു പേൾ കോഡ് ലേക്ക് വേല കൂടെ makepp
ഓരോ മേക്ക് ഫയലും അതിൻ്റേതായ പാക്കേജിലാണ് ജീവിക്കുന്നത്. അതിനാൽ ഒരു മേക്ക് ഫയലിലെ നിർവചനങ്ങൾ ബാധിക്കില്ല
മറ്റൊരു മേക്ക് ഫയലിലെ നിർവചനങ്ങൾ. എല്ലാ സ്റ്റാൻഡേർഡും ഉൾപ്പെടെയുള്ള ഒരു പൊതു സെറ്റ് ഫംഗ്‌ഷനുകൾ
ടെക്‌സ്‌ച്വൽ മാനിപ്പുലേഷൻ ഫംഗ്‌ഷനുകൾ പാക്കേജ് സൃഷ്‌ടിക്കുമ്പോൾ അതിലേക്ക് ഇറക്കുമതി ചെയ്യുന്നു.

Makefile വേരിയബിളുകൾ ആ പാക്കേജിൽ Perl സ്കെയിലർ ആയി സംഭരിച്ചിരിക്കുന്നു. (ഒഴിവാക്കലുകൾ ഉണ്ട്
ഇത്: ഓട്ടോമാറ്റിക് വേരിയബിളുകളും CC പോലുള്ള വേരിയബിളുകളുടെ സ്ഥിര മൂല്യവും യഥാർത്ഥമാണ്
ആർഗ്യുമെൻ്റുകളില്ലാതെ ഫംഗ്‌ഷനുകളായി നടപ്പിലാക്കി. ടാർഗെറ്റ് നിർദ്ദിഷ്ട vars, കമാൻഡ് ലൈൻ vars ഒപ്പം
എൻവയോൺമെൻ്റ് vars ഈ രീതിയിൽ കാണില്ല.) അതിനാൽ നിങ്ങൾ എഴുതുന്ന ഏതൊരു Perl കോഡിനും എല്ലാവരിലേക്കും ആക്‌സസ് ഉണ്ട്
makefile വേരിയബിളുകൾ. ഗ്ലോബൽ വേരിയബിളുകൾ "Mpp::global" പാക്കേജിൽ സംഭരിച്ചിരിക്കുന്നു. കാണുക
വിശദാംശങ്ങൾക്കായി Makefile വേരിയബിളുകൾ.

ഓരോ പ്രസ്താവനകളും (ifperl / ifmakeperl, perl / makeperl, sub / makeub),
ഫംഗ്ഷനുകളും (perl / makeperl, map / makemap) റൂൾ ആക്ഷൻ (perl / makeperl)
മേക്ക് ഫയലിൽ നേരിട്ട് പേൾ കോഡ് എഴുതുന്നത് രണ്ട് ഫ്ലേവറുകളിൽ വരുന്നു. ആദ്യത്തേത് തികച്ചും
സാധാരണ പേൾ, അതായത്, അടുത്ത വിഭാഗത്തിൽ വിശദീകരിച്ചിരിക്കുന്നതുപോലെ നിങ്ങൾ "f_" പ്രിഫിക്സ് ഉപയോഗിക്കണം
നിങ്ങൾ makepp ഫംഗ്‌ഷനുകൾ വിളിക്കാൻ ആഗ്രഹിക്കുന്നു. രണ്ടാമത്തെ വേരിയൻ്റ് ആദ്യം പ്രസ്താവനയിലൂടെ കടന്നുപോകുന്നു
മേക്ക്-സ്റ്റൈൽ വേരിയബിൾ എക്സ്പാൻഷൻ, അതായത് നിങ്ങൾ പേൾ കാണാൻ ആഗ്രഹിക്കുന്ന "$" കൾ ഇരട്ടിയാക്കണം.

എൻഡ് ഹാൻഡ്‌ലിംഗ് സവിശേഷമാണ്, കാരണം makepp-ൻ്റെ വലിയ (നിങ്ങളുടെ ബിൽഡ് സിസ്റ്റത്തെ ആശ്രയിച്ച്) ഡാറ്റയാണ്
ഒരു സാധാരണ എക്സിറ്റ് ഉപയോഗിച്ച് മാലിന്യങ്ങൾ ശേഖരിക്കാൻ ഘടനകൾ കുറച്ച് സെക്കൻ്റുകൾ എടുക്കും. അതിനാൽ ഞങ്ങൾ ഒരു ചെയ്യുന്നു
ബ്രൂട്ട് ഫോഴ്സ് എക്സിറ്റ്. പ്രധാന പ്രക്രിയയിൽ നിങ്ങൾക്ക് ഇപ്പോഴും "END" ബ്ലോക്കുകൾ ഉണ്ടായിരിക്കാം, എന്നാൽ നിങ്ങൾക്ക് എന്തെങ്കിലും ഉണ്ടെങ്കിൽ
ഗ്ലോബൽ ഫയൽ ഹാൻഡിലുകൾ ഫ്ലഷ് ചെയ്യപ്പെടില്ല. എന്നാൽ നിങ്ങൾ ആധുനിക ലെക്സിക്കൽ ഉപയോഗിക്കണം
സ്കോപ്പിന് പുറത്ത് പോകുമ്പോൾ ശരിയായി അടയുന്ന ഫയൽ ഹാൻഡിൽസ്.

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

ചേർക്കുന്നു പുതിയ വാചകം ഫംഗ്ഷനുകളും
ഒരു പേൾ സബ്റൂട്ടീൻ നിർവചിച്ചുകൊണ്ട് നിങ്ങൾക്ക് makepp ൻ്റെ ശേഖരത്തിലേക്ക് ഒരു പുതിയ ഫംഗ്ഷൻ ചേർക്കാൻ കഴിയും
അതേ പേര് എന്നാൽ "f_" എന്ന പ്രിഫിക്‌സിനൊപ്പം. ഉദാഹരണത്തിന്:

ഉപ f_myfunc {
എൻ്റെ $ വാദം = & arg; # വാദത്തിന് പേര് നൽകുക.
my( undef, $mkfile, $mkfile_line ) = @_; # വാദങ്ങൾക്ക് പേര് നൽകുക.

... ഇവിടെ എന്തെങ്കിലും ചെയ്യൂ

$return_value തിരികെ നൽകുക;
}

XYZ := $(myfunc my func arguments)

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

ഈ ആക്‌സസ്സറുകൾ ഏതെങ്കിലും "f_" ലേക്ക് കൈമാറേണ്ട അതേ മൂന്ന് പാരാമീറ്ററുകൾ പ്രോസസ്സ് ചെയ്യുന്നു
ഫംഗ്‌ഷൻ, അതായത് ഫംഗ്‌ഷൻ ആർഗ്യുമെൻ്റുകൾ, മേക്ക്‌ഫൈൽ ഒബ്‌ജക്‌റ്റ്, അതിനുള്ള ഒരു ലൈൻ ഡിസ്‌ക്രിപ്‌റ്റർ
സന്ദേശങ്ങൾ. അതിനാൽ നിങ്ങൾക്ക് ആദ്യ സന്ദർഭത്തിൽ കാര്യക്ഷമമായ &ആർഗ് ഫോം ഉപയോഗിക്കാം.

&arg ആക്‌സസ്സർ നിങ്ങൾക്കായി ഇനിപ്പറയുന്നവ ശ്രദ്ധിക്കുന്നു: ആർഗ്യുമെൻ്റുകൾ ഇതിനകം ഉണ്ടായിരുന്നെങ്കിൽ
വിപുലീകരിച്ചത് (ഉദാ: "$(my$(function) arg) എന്നതിൽ ഫംഗ്‌ഷൻ്റെ പേര് കണ്ടെത്താൻ, arg ആണ്
ഒരു ചരടായി കടന്നുപോയി, ഇപ്പോൾ തിരിച്ചെത്തി. വാദത്തിന് ഇനിയും വിപുലീകരണം ആവശ്യമാണെങ്കിൽ, ഇതാണ്
സാധാരണ കേസ്, പകരം ഇത് ഒരു സ്ട്രിംഗിലേക്കുള്ള ഒരു റഫറൻസാണ്. &arg ആക്‌സസ്സർ നിങ്ങൾക്കായി ഇത് വിപുലീകരിക്കുന്നു,
അതിന് അതിൻ്റെ 2-ാമത്തെ പാരാമീറ്ററായി makefile ഒബ്ജക്റ്റ് ആവശ്യമാണ്.

നിങ്ങൾ കൂടുതൽ ആർഗ്യുമെൻ്റുകൾ പ്രതീക്ഷിക്കുന്നുവെങ്കിൽ, വേരിയബിൾ നമ്പറിൽ, ജോലി നിർവഹിക്കുന്നത് "args" ആണ്.
ഈ ആക്‌സസ്സർ arg-ൻ്റെ അതേ 3 പാരാമീറ്ററുകളും അധിക പാരാമീറ്ററുകളും എടുക്കുന്നു:

പരമാവധി: ആർഗുകളുടെ എണ്ണം (ഡിഫോൾട്ട് 2): അനന്തമായതിന് ~0 (മാക്സിൻ്റ്) നൽകുക
മിനിറ്റ്: ആർഗുകളുടെ എണ്ണം (പരമാവധി ~0 ആണെങ്കിൽ ഡിഫോൾട്ട് 0, അല്ലെങ്കിൽ പരമാവധി പോലെ)
only_comma: ഫയലിൻ്റെ പേരല്ലാത്തതിന് സാധാരണ കോമകൾക്ക് ചുറ്റും ഇടം നൽകരുത്

പരമാവധി, എന്നാൽ വിപുലീകരണത്തിന് മുമ്പുള്ള മിനിമം കോമകൾ വിഭജിക്കാൻ ഉപയോഗിക്കുന്നു
വാദങ്ങൾ. makepp-ൻ്റെ ബിൽറ്റ്ഇൻ ഫംഗ്‌ഷനുകളിൽ നിന്നുള്ള ചില ഉദാഹരണങ്ങൾ:

my($prefix, $text ) = args $_[0], $_[1], $_[2], 2, 2, 1; # ആഡ്പ്രിഫിക്സ്
എൻ്റെ $cond (args $_[0], undef, $_[2], ~0 ) ... # ഒപ്പം, അല്ലെങ്കിൽ
എൻ്റെ @args= args $_[0], $_[1], $_[2], ~0, 1, 1; # വിളി
my($filters, $words ) = args $_[0], $_[1], $_[2]; # ഫിൽട്ടർ

ഫംഗ്‌ഷൻ ഒരു സ്‌കെലാർ സ്‌ട്രിംഗ് (അറേ അല്ല) തിരികെ നൽകണം, അത് പിന്നീട് ഇതിലേക്ക് ചേർക്കും
ആ ഘട്ടത്തിൽ വാചകം.

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

പ്രവർത്തനത്തിന് എന്തുചെയ്യാൻ കഴിയും എന്നതിന് അടിസ്ഥാനപരമായി പരിധികളൊന്നുമില്ല; നിങ്ങൾക്ക് ഫയൽ ആക്സസ് ചെയ്യാം, പ്രവർത്തിപ്പിക്കുക
ഷെൽ കമാൻഡുകൾ മുതലായവ.

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

ഫംഗ്‌ഷൻ വിലയിരുത്തുന്ന പരിസ്ഥിതി (പ്രത്യേകിച്ച്, cwd) ഇച്ഛാശക്തിയുള്ളതാണെന്ന കാര്യം ശ്രദ്ധിക്കുക
Makefile-ൽ നിന്നുള്ള നിയമങ്ങൾ ഏത് പരിതസ്ഥിതിയുമായി പൊരുത്തപ്പെടണമെന്നില്ല
പ്രവർത്തനം വിലയിരുത്തി നടപ്പിലാക്കി. ഇത് നിങ്ങൾക്ക് ഒരു പ്രശ്നമാണെങ്കിൽ, നിങ്ങളുടെ പ്രവർത്തനം
ഒരുപക്ഷേ ഇതുപോലെ ഒന്ന് കാണണം:

ഉപ f_foo {
...
chdir $makefile->{CWD};

... തുടങ്ങിയവ.
}

നിർത്തുന്നു ഫംഗ്ഷനുകളും കടന്നു a പേൾ മൊഡ്യൂൾ
നിങ്ങൾ ഒരു ഉൾപ്പെടുത്തിയ ഫയലിൽ ഫംഗ്‌ഷനുകൾ ഇടുകയാണെങ്കിൽ, ഓരോ Makeppfile-ലും നിങ്ങൾക്ക് ഒരു പകർപ്പ് ഉണ്ടായിരിക്കും
അത് ഉപയോഗിക്കുന്നു. അത് ഒഴിവാക്കാൻ, നിങ്ങൾക്ക് അവ ഒരു "കയറ്റുമതിക്കാരൻ" ഉപയോഗിച്ച് ഒരു സാധാരണ Perl മൊഡ്യൂളായി എഴുതാം.
ഇൻ്റർഫേസ്, അത് ഉപയോഗിക്കുക. ഇത് വേഗത്തിൽ ലോഡ് ചെയ്യുകയും മെമ്മറി സംരക്ഷിക്കുകയും ചെയ്യും:

perl {മൈമോഡ്യൂൾ ഉപയോഗിക്കുക}
perl {
എൻ്റെ :: മൊഡ്യൂൾ ഉപയോഗിക്കുക; # ഇടുക : ഒരു പുതിയ ലൈനിൽ ഇത് ഒരു ചട്ടം പോലെ പാഴ്‌സ് ചെയ്യില്ല
}

ഒരു Makefile-ൽ സാധാരണയായി ലഭ്യമായ ഏതെങ്കിലും ഫംഗ്ഷനുകൾ നിങ്ങൾക്ക് ആവശ്യമുണ്ടെങ്കിൽ ("f_" പോലെ
ഫംഗ്ഷനുകൾ, "arg" അല്ലെങ്കിൽ "args"), നിങ്ങൾ ഈ വരി നിങ്ങളുടെ മൊഡ്യൂളിൽ ഉൾപ്പെടുത്തണം:

Mpp::Subs ഉപയോഗിക്കുക;

മൊഡ്യൂൾ നേരിട്ട് ഒരു ഫംഗ്‌ഷനിൽ നിന്ന് വ്യത്യസ്തമായ പാക്കേജിലായിരിക്കും എന്നതാണ് പോരായ്മ
ഒരു മേക്ക് ഫയലിൽ പ്രത്യക്ഷപ്പെടുന്നു. അതിനാൽ നിങ്ങൾ എല്ലാം പാരാമീറ്ററുകളായി കടന്നുപോകേണ്ടതുണ്ട്, അല്ലെങ്കിൽ നിർമ്മിക്കുക
പേളിൻ്റെ "കോളർ" ഫംഗ്‌ഷനുള്ള പേരുകൾ.

വിളിക്കുന്നു പുറമേയുള്ള പേൾ സ്ക്രിപ്റ്റുകൾ
നിങ്ങൾ "സിസ്റ്റം" വഴിയോ ഒരു റൂൾ ആക്ഷൻ എന്ന നിലയിലോ ഒരു എക്‌സ്‌റ്റേണൽ പേൾ സ്‌ക്രിപ്റ്റ് വിളിക്കുകയാണെങ്കിൽ, makepp ഫോർക്ക് എ
പുതിയ പ്രോസസ്സ് (ഇത് അവസാന റൂൾ ആക്ഷൻ അല്ലാത്ത പക്ഷം) ഒരു പുതിയ പെർൾ ഇൻ്റർപ്രെട്ടർ ഓഫ് ചെയ്യുക.
കൂടുതൽ കാര്യക്ഷമമായ മാർഗമുണ്ടെന്നതൊഴിച്ചാൽ അതിൽ തെറ്റൊന്നുമില്ല:

&കമാൻഡ് വാദങ്ങൾ...
ഇതൊരു നിയമ നടപടിയായിരിക്കാം. ഇത് ഒരു ഫംഗ്ഷൻ വിളിക്കും കമാൻഡ് ഒരു "c_" പ്രിഫിക്സിനൊപ്പം, ഒപ്പം
ബാക്കിയുള്ളത് കൈമാറുക (ഓപ്ഷണലായി ഉദ്ധരിച്ച മേക്കപ്പ് ശൈലി -- കൃത്യമായി സമാനമല്ല
ഷെൽ) വാദങ്ങൾ. അത്തരമൊരു ഫംഗ്ഷൻ കണ്ടെത്താൻ കഴിയുന്നില്ലെങ്കിൽ, ഇത് എല്ലാ സ്ട്രിംഗുകളിലേക്കും കടക്കുന്നു
"ഓടുക".

sub c_mycmd {my @args = @_; ...}

$(ഫോണി callcmd):
&mycmd 'arg with space' arg2 "arg3" # calls c_mycmd

%.out: %.in
&myscript -o $(ഔട്ട്പുട്ട്) $(ഇൻപുട്ട്) # ബാഹ്യ മൈസ്ക്രിപ്റ്റ് വിളിക്കുന്നു

ബിൽഡിനുകളുടെ ചട്ടക്കൂടിനുള്ളിൽ നിങ്ങൾക്ക് കമാൻഡുകൾ എഴുതാം, അത് ഉപയോഗിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു
അവർക്കുള്ള അതേ സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകളും അവർ നൽകുന്ന I/O കൈകാര്യം ചെയ്യലും.

ബ്ലോക്ക് ഓപ്പറേറ്റർ "Mpp::Cmds::frame" എന്നതിൻ്റെ ഒരു ഒറ്റ അക്ഷര ഓപ്‌ഷൻ ലിസ്റ്റ് പിന്തുടരുന്നു
ബിൽഡിനുകൾ (പരമാവധി "qw(fi I ​​o O rs)"). നിങ്ങളുടെ സ്വന്തം ഓപ്ഷൻ വ്യക്തമാക്കിയാലും
ഇവയിലൊന്നിനെ മറികടന്ന്, നിങ്ങൾ ഇപ്പോഴും സ്റ്റാൻഡേർഡ് ഓപ്ഷൻ്റെ ഒറ്റ അക്ഷരം നൽകുന്നു.

ഓരോ ഓപ്ഷനും "[qw(n name), \$ref, ആർഗ്, ഉപ]". ആദ്യ രണ്ട്
മൂലകങ്ങൾ ചെറുതും നീളമുള്ളതുമായ പേരാണ്, തുടർന്ന് വേരിയബിൾ റഫറൻസും ഓപ്ഷണലായി വഴിയും
ഒരു വാദം എടുക്കണമോ എന്നതിനുള്ള ഒരു ബൂളിയൻ. ഒരു ആർഗ് ഇല്ലാതെ, വേരിയബിൾ ആണ്
ഓരോ തവണയും ഓപ്‌ഷൻ നൽകുമ്പോൾ വർദ്ധിപ്പിക്കും, അല്ലെങ്കിൽ ഓപ്ഷൻ മൂല്യം അതിൽ സംഭരിക്കും.

sub c_my_ocmd { # സാധാരണ ഔട്ട്പുട്ട് കേസ്
പ്രാദേശിക @ARGV = @_;
Mpp::Cmds::frame {

... ഇതിനകം സ്വയമേവ നീക്കം ചെയ്ത ഓപ്ഷനുകൾക്കൊപ്പം @ARGV ഉപയോഗിച്ച് ഇവിടെ എന്തെങ്കിലും പ്രിൻ്റ് ചെയ്യുക

} 'f', qw(o O);
}

sub c_my_icmd { # 2 ഓപ്ഷനുകളുള്ള സാധാരണ ഇൻപുട്ട് കേസ്
പ്രാദേശിക @ARGV = @_;
എൻ്റെ ($ഹ്രസ്വ, $നീളം);
Mpp::Cmds::frame {

... <> ഉപയോഗിച്ച് ഇവിടെ എന്തെങ്കിലും ചെയ്യുക

} qw(i I rs), # s --സെപ്പറേറ്റർ മാത്രം വ്യക്തമാക്കുന്നു, -s അല്ല
[qw(s short), \$short], # ഓപ്‌ഷൻ ഇല്ല arg -> $short == 1
[qw(l long), \$long, 1, sub {warn "got arg $long"}];
}

ഓരോ ഇൻപുട്ടിൻ്റെയും ആദ്യ പ്രതീകം മാത്രം അപ്‌കേസ് ചെയ്യുന്ന ഒരു ലളിതമായ കമാൻഡ് ഇതാ വരുന്നു
റെക്കോർഡ് ("&sed '$$_ = "\u\L$$_"'" എന്നതിന് തുല്യം):

ഉപ c_uc {
പ്രാദേശിക @ARGV = @_;
Mpp::Cmds::frame {
<> അതേസമയം "\u\L$_" പ്രിൻ്റ് ചെയ്യുക;
} 'f', qw(i I o O rs);
}

ഫ്രെയിം കൈകാര്യം ചെയ്യുന്ന ബ്ലോക്കിനുള്ളിൽ, നിർണായക പ്രകടനം നടത്താൻ നിങ്ങൾക്ക് നെസ്റ്റഡ് ബ്ലോക്കുകൾ ഉണ്ടായിരിക്കാം
മറ്റ് ഫയലുകൾ തുറക്കുന്നത് പോലെയുള്ള പ്രവർത്തനങ്ങൾ.

Mpp::Cmds:: പ്രകടനം { ... } 'സന്ദേശം';

ഇത് "--verbose" (എല്ലാ കമാൻഡും സ്വീകരിക്കുന്ന) ഉപയോഗിച്ച് സന്ദേശം ഔട്ട്പുട്ട് ചെയ്യും
കമാൻഡ് വിജയകരമായി പ്രവർത്തിക്കുന്നു. എന്നാൽ ബ്ലോക്ക് തെറ്റാണെന്ന് വിലയിരുത്തിയാൽ, അത് മരിക്കും
നിഷേധിക്കപ്പെട്ട സന്ദേശം.

ഓടുക സ്ക്രിപ്റ്റ് വാദങ്ങൾ...
നിങ്ങളുടെ മേക്ക് ഫയലിനുള്ളിലെ ഏത് പെർൽ സന്ദർഭത്തിലും നിങ്ങൾക്ക് ഉപയോഗിക്കാനാകുന്ന ഒരു സാധാരണ Perl ഫംഗ്‌ഷനാണിത്.
ഇത് സിസ്റ്റത്തിൻ്റെ മൾട്ടി-ആർഗ്യുമെൻ്റ് രൂപത്തിന് സമാനമാണ്, പക്ഷേ ഇത് ഉള്ളിൽ പേൾ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുന്നു
നിലവിലെ പ്രക്രിയ. makepp പ്രസ്താവനകൾക്കായി, perl ഫംഗ്‌ഷൻ അല്ലെങ്കിൽ നിങ്ങളുടെ സ്വന്തം ഫംഗ്‌ഷനുകൾ
അതാണ് makepp പ്രവർത്തിക്കുന്ന പ്രക്രിയ. എന്നാൽ ഒരു റൂളിനെ സംബന്ധിച്ചിടത്തോളം അത് ഉപപ്രോസസ് ആണ്
അത്. സ്ക്രിപ്റ്റ് എത്ര തവണ വിളിക്കുന്നുവോ അത്രയും തവണ പാഴ്‌സ് ചെയ്യപ്പെടുന്നു, പക്ഷേ നിങ്ങൾക്ക് യഥാർത്ഥമായത് നൽകാം
pod2html ചെയ്യുന്നതുപോലെ ഒരു ലിബിൽ പ്രവർത്തിക്കുക. ഈ ലിബ് പിന്നീട് ഉയർന്ന തലത്തിൽ ഉപയോഗിക്കാനാകും, അതിനാൽ
അത് ഇതിനകം നിലവിലുണ്ട്:

perl {mylib ഉപയോഗിക്കുക } # അത് പുനഃപരിശോധിക്കേണ്ടതില്ലാത്ത എല്ലാ നിയമങ്ങളും ലംഘിച്ചു

%.out: %.in
makeperl { qw'myscript -o $(ഔട്ട്‌പുട്ട്) $(ഇൻപുട്ട്)'} പ്രവർത്തിപ്പിക്കുക

സ്ക്രിപ്റ്റ് "എക്സിറ്റ്" എന്ന് വിളിക്കുകയാണെങ്കിൽ, സ്റ്റാൻഡേർഡ് ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ അടയ്ക്കുകയോ സിസ്റ്റത്തെ ആശ്രയിക്കുകയോ ചെയ്യുന്നു
അതിനു ശേഷം വൃത്തിയാക്കാൻ (ഓപ്പൺ ഫയലുകൾ, മെമ്മറി...), ഇത് "റൺ" എന്നതിൽ ഒരു പ്രശ്നമാകാം. എങ്കിൽ
നിങ്ങൾ പ്രസ്താവനകൾ അല്ലെങ്കിൽ perl ഫംഗ്‌ഷൻ ഉള്ളിൽ "റൺ" എന്ന് വിളിക്കുന്നു, makepp അസ്വസ്ഥനാകാം അല്ലെങ്കിൽ
മേക്കപ്പിൻ്റെ അവസാനത്തിൽ മാത്രമേ വൃത്തിയാക്കൽ നടക്കൂ.

നിങ്ങൾക്ക് മുകളിൽ പറഞ്ഞ പ്രശ്‌നങ്ങളുണ്ടെങ്കിൽ, സ്‌ക്രിപ്റ്റ് ബാഹ്യമായി പ്രവർത്തിപ്പിക്കുക, അതായത് നിന്ന്
പകരം കമാൻഡ് ലൈൻ. ഒരു നിയമത്തിനുള്ളിൽ വൃത്തിയാക്കൽ ഒരു പ്രശ്നമല്ല, പ്രത്യേകിച്ച് അല്ല
ഒരു റൂളിൻ്റെ അവസാന പ്രവർത്തനമെന്ന നിലയിൽ, റൂൾ സബ്പ്രോസസ് എന്തായാലും ശേഷം പുറത്തുകടക്കും,
വിൻഡോസ് ഒഴികെ.

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

ഇത് പല തരത്തിൽ നിർവ്വഹിക്കാവുന്നതാണ്. നിങ്ങളുടേതായ പുതിയത് സൃഷ്ടിക്കുക എന്നതാണ് ഏറ്റവും എളുപ്പമുള്ള മാർഗം
സിഗ്നേച്ചർ രീതി (നമുക്ക് ഇതിനെ "പങ്കിട്ട_വസ്തു" എന്ന് വിളിക്കാം). നിങ്ങൾ ഈ സിഗ്നേച്ചർ രീതി ഉപയോഗിക്കും
ഇതുപോലുള്ള ബൈനറികളെ ബന്ധിപ്പിക്കുന്ന നിയമങ്ങളിൽ മാത്രം:

myprogram : *.o lib1/lib1.so lib2/lib2.so
: ഒപ്പ് പങ്കിട്ട_വസ്തു
$(CC) $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്പുട്ട്)

ഇനി നമ്മൾ സിഗ്നേച്ചർ മെത്തേഡ് ഉണ്ടാക്കണം.

എല്ലാ സിഗ്നേച്ചർ രീതികളും അവരുടെ സ്വന്തം ക്ലാസ് ആയിരിക്കണം, കൂടാതെ ക്ലാസിൽ കുറച്ച് പ്രത്യേകം അടങ്ങിയിരിക്കണം
ഇനങ്ങൾ (വിശദാംശങ്ങൾക്ക് വിതരണത്തിലെ Mpp/Signature.pm കാണുക). ക്ലാസിൻ്റെ പേര് ആയിരിക്കണം
"Mpp::സിഗ്നേച്ചർ::" എന്ന പ്രിഫിക്‌സ്, അതിനാൽ ഈ സാഹചര്യത്തിൽ ഞങ്ങളുടെ ക്ലാസ്സിനെ വിളിക്കണം
"എംപിപി::ഒപ്പ്::പങ്കിട്ട_വസ്തു". എന്ന പേരിൽ ഒരു ഫയൽ ഉണ്ടാക്കണം share_object.pm ഇട്ടു
അത് എ ആയി Mpp::ഒപ്പ് പേളിൽ എവിടെയോ ഡയറക്‌ടറി ഉൾപ്പെടുന്നു പാത; ഏറ്റവും എളുപ്പമുള്ള സ്ഥലം
ൽ ആയിരിക്കാം Mpp/ഒപ്പ് makepp ഇൻസ്റ്റലേഷനിലെ ഡയറക്ടറി (ഉദാ,
/usr/local/share/makepp/Mpp/Signature അല്ലെങ്കിൽ നിങ്ങൾ എവിടെ ഇൻസ്റ്റാൾ ചെയ്താലും).

ഈ ക്ലാസിൽ എന്താണ് ചെയ്യേണ്ടത് എന്നതിനെക്കുറിച്ചുള്ള കൃത്യമായ വിശദാംശങ്ങൾക്ക്, നിങ്ങൾ ശ്രദ്ധാപൂർവ്വം നോക്കണം
ഫയല് Mpp/Signature.pm കൂടാതെ ഒരുപക്ഷേ Mpp/Signature/exact_match.pm മേക്കപ്പിൽ
വിതരണ. എന്നാൽ ഞങ്ങളുടെ കാര്യത്തിൽ, ഞങ്ങൾ ചെയ്യാൻ ആഗ്രഹിക്കുന്നത് ഒരു ചെറിയ മാറ്റം മാത്രമാണ്
നിലവിലുള്ള സിഗ്നേച്ചർ സംവിധാനം; ഫയൽ ഒരു പങ്കിട്ട ലൈബ്രറിയാണെങ്കിൽ, ഞങ്ങൾക്ക് ഒരു സ്ഥിരാങ്കം വേണം
ഒപ്പ്, ഫയൽ മറ്റെന്തെങ്കിലും ആണെങ്കിൽ, ഞങ്ങൾ makepp-ൻ്റെ നോർമലിനെ ആശ്രയിക്കാൻ ആഗ്രഹിക്കുന്നു
ഒപ്പ് സംവിധാനം. ഇതിനുള്ള ഏറ്റവും നല്ല മാർഗം പാരമ്പര്യമായി എടുക്കുക എന്നതാണ്
"Mpp::Signature::c_compilation_md5", സാധാരണയായി തിരഞ്ഞെടുക്കുന്ന സിഗ്നേച്ചർ രീതിയാണിത്
makepp ഒരു ലിങ്ക് കമാൻഡ് തിരിച്ചറിയുമ്പോൾ.

അതിനാൽ ഫയൽ Mpp/Signature/shared_object.pm ഇനിപ്പറയുന്നവ അടങ്ങിയിരിക്കാം:

കർശനമായി ഉപയോഗിക്കുക;
പാക്കേജ് Mpp::Signature::shared_object;
Mpp::Signature::c_compilation_md5 ഉപയോഗിക്കുക;
ഞങ്ങളുടെ @ISA = qw (Mpp:: ഒപ്പ്:: c_compilation_md5); # അനന്തരാവകാശം സൂചിപ്പിക്കുക.
ഞങ്ങളുടെ $shared_object = അനുഗ്രഹിക്കൂ \@ISA; # മേക്കപ്പിനെ കണ്ടെത്താൻ സഹായിക്കുന്ന ഒരു മാജിക്
# ഈ രീതിക്കുള്ള സബ്റൂട്ടീനുകൾ. എല്ലാം
# സിഗ്നേച്ചർ രീതികളിൽ ഇവയിലൊന്ന് ഉണ്ടായിരിക്കണം.
# മൂല്യം ഉപയോഗിക്കുന്നില്ല, ഏതെങ്കിലും ഒബ്ജക്റ്റ് മാത്രം.
# ഇപ്പോൾ നമുക്ക് ഒപ്പ് ആവശ്യമുള്ളപ്പോൾ വിളിക്കുന്ന രീതി ഇതാ
# ഈ സിഗ്നേച്ചർ രീതി സജീവമായ ഏതെങ്കിലും ലക്ഷ്യമോ ആശ്രിതത്വമോ:
ഉപ ഒപ്പ് {
എൻ്റെ ($self, # ഇത് $shared_object പോലെ തന്നെ ആയിരിക്കും.
$finfo) = @_; # എല്ലാം ഉൾക്കൊള്ളുന്ന ഒരു പ്രത്യേക ഘടന
# makepp-ന് ഈ ഫയലിനെക്കുറിച്ച് അറിയാം. കാണുക
വിശദാംശങ്ങൾക്ക് # Mpp/File.pm.

എങ്കിൽ ($finfo->{NAME} =~ /\.s[oa]$/) { # ഫയലിൻ്റെ പേര് .so അല്ലെങ്കിൽ .sa എന്നതിൽ അവസാനിക്കുമോ?
തിരികെ $finfo->file_exist ? 'നിലവിലുണ്ട്' : '';
# ഫയലാണെങ്കിൽ എല്ലായ്പ്പോഴും ഒരേ ഒപ്പ് തിരികെ നൽകുക
# നിലവിലുണ്ട്. ഈ സാഹചര്യത്തിൽ, ഒപ്പ് ആണ്
# സ്ട്രിംഗ് "നിലവിലുണ്ട്".
}

Mpp::Signature::c_compilation_md5:: ഒപ്പ്;
# ഫയൽ .so അല്ലെങ്കിൽ .sa എന്നതിൽ അവസാനിച്ചിട്ടില്ലെങ്കിൽ,
മേക്കപ്പിൻ്റെ സാധാരണ സിഗ്നേച്ചർ രീതിയിലേക്ക് # ഡെലിഗേറ്റ് ചെയ്യുക.
}

ഈ ഫയൽ മേക്കപ്പ് വിതരണത്തിൽ ഒരു ഉദാഹരണമായി നൽകിയിരിക്കുന്നു
അഭിപ്രായങ്ങൾ.

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

ഉദാഹരണത്തിന്, പങ്കിട്ട ലൈബ്രറി നിങ്ങളുടെ പ്രോഗ്രാമിൻ്റെ ചില സബ്റൂട്ടീനുകൾ ആവശ്യപ്പെടുന്നു എന്ന് കരുതുക
നൽകുന്നു. ഉദാ, നിങ്ങൾ പങ്കിട്ട ലൈബ്രറി മാറ്റുന്നു, അതിനാൽ അത് ഇപ്പോൾ ഒരു എക്‌സ്‌റ്റേണൽ എന്ന് വിളിക്കുന്നു
സബ്റൂട്ടീൻ "xyz()". നിങ്ങൾ ലിങ്കറിലേക്ക് "-E" അല്ലെങ്കിൽ "--export-dynamic" ഓപ്ഷൻ ഉപയോഗിക്കുന്നില്ലെങ്കിൽ
(GNU binutils-ന്; മറ്റ് ലിങ്കറുകൾക്ക് വ്യത്യസ്ത ഓപ്‌ഷൻ പേരുകൾ ഉണ്ട്), "xyz()" എന്ന ചിഹ്നം പാടില്ല
നിങ്ങളുടെ പ്രോഗ്രാമിൽ നിലവിലുണ്ടെങ്കിൽപ്പോലും റൺ-ടൈം ലിങ്കറിലേക്ക് ആക്സസ് ചെയ്യാവുന്നതാണ്.

അതിലും മോശം, നിങ്ങൾ മറ്റൊരു ലൈബ്രറിയിൽ "xyz()" നിർവചിച്ചതായി കരുതുക (അതിനെ വിളിക്കുക libxyz), ഇതുപോലെ:

my_program: main.o lib1/lib1.so xyz/libxyz.a

"libxyz" ആയതിനാൽ a .a ഫയൽ അല്ല എ .സോ ഫയൽ, തുടർന്ന് "xyz()" അകത്തേക്ക് വലിക്കാനിടയില്ല
കൃത്യമായി നിന്ന് libxyz.a നിങ്ങളുടെ ബൈനറി വീണ്ടും ലിങ്ക് ചെയ്തില്ലെങ്കിൽ.

Mpp::എ ആണോ എന്ന് നിർണ്ണയിക്കാൻ ഉപയോഗിക്കുന്ന സ്ട്രിംഗിനെ മാത്രമല്ല സിഗ്നേച്ചർ രീതികളും നിയന്ത്രിക്കുന്നു
ഫയൽ മാറി, പക്ഷേ സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യാൻ ഉപയോഗിക്കുന്ന അൽഗോരിതം. ഉദാഹരണത്തിന്, ദി
makepp ഡിസ്ട്രിബ്യൂഷനിലെ സിഗ്നേച്ചർ രീതി "target_newer" ന് അത് ആവശ്യമാണ്
ലക്ഷ്യങ്ങൾ ഡിപൻഡൻസികളേക്കാൾ പുതിയതായിരിക്കും, അതേസമയം സിഗ്നേച്ചർ രീതി "exact_match" (കൂടാതെ
"md5", "c_compilation_md5" എന്നിവ പോലെ അതിനെ ആശ്രയിക്കുന്ന എല്ലാത്തിനും അത് ആവശ്യമാണ്
ഫയലിന് അവസാന ബിൽഡിലേതിന് സമാനമായ ഒപ്പ് ഉണ്ട്.

നിങ്ങളെ മനസ്സിലാക്കാൻ സഹായിക്കുന്നതിന് ഉപയോഗപ്രദമായേക്കാവുന്ന മറ്റ് ചില സിഗ്നേച്ചർ രീതികൾ ഇതാ
സാധ്യതകൾ. പൊതുവായ ഉദ്ദേശം മതിയെങ്കിൽ, ഇവയിൽ ചിലത് ഒടുവിൽ ഉണ്ടായേക്കാം
മേക്കപ്പിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്:

· കയറ്റുമതി ചെയ്ത എല്ലാത്തിൻ്റേയും ചെക്ക്സം തിരികെ നൽകുന്ന പങ്കിട്ട ലൈബ്രറികൾക്കുള്ള ഒരു സിഗ്നേച്ചർ രീതി
ചിഹ്നങ്ങൾ, കൂടാതെ മറ്റ് ലൈബ്രറികളിൽ നിന്ന് ആവശ്യമായ എല്ലാ ചിഹ്നങ്ങളും. ഇത് പരിഹരിക്കുന്നു
മുകളിലുള്ള ഉദാഹരണത്തിലെ പ്രശ്നം, എല്ലാ സാഹചര്യങ്ങളിലും ശരിയായ ലിങ്ക് ഉറപ്പുനൽകുന്നു.
മേക്കപ്പ് വിതരണത്തിൽ ഇത് ചെയ്യാൻ ഒരു പരീക്ഷണാത്മക ശ്രമം നടത്തിയിട്ടുണ്ട് (കാണുക
Mpp/Signature/shared_object.pm), എന്നാൽ ഇത് GNU binutils, ELF എന്നിവയിൽ മാത്രമേ പ്രവർത്തിക്കൂ
ഇപ്പോൾ ലൈബ്രറികൾ.

ഒരു ഫയലിൽ എഴുതിയ തീയതി സ്റ്റാമ്പ് അവഗണിക്കുന്ന ഒരു സിഗ്നേച്ചർ രീതി. ഉദാ, നിങ്ങളാണെങ്കിൽ
സൃഷ്ടിക്കുക a .c ഒരു സ്ട്രിംഗ് ഇടാൻ നിർബന്ധിക്കുന്ന ചില പ്രോഗ്രാം ഉപയോഗിച്ച് യാന്ത്രികമായി ഫയൽ ചെയ്യുക
ഇതുപോലെ:

സ്റ്റാറ്റിക് ചാർ * date_stamp = "ആരും 01 ഏപ്രിൽ 2004-ന് സ്വയമേവ സൃഷ്ടിച്ചത്";

തീയതി സ്റ്റാമ്പുകളിലെ മാറ്റങ്ങൾ പ്രത്യേകമായി അവഗണിക്കുന്ന ഒരു സിഗ്നേച്ചർ രീതി നിങ്ങൾക്ക് എഴുതാം.
അങ്ങനെ തീയതി സ്റ്റാമ്പ് മാത്രമാണ് മാറിയതെങ്കിൽ, makepp പുനർനിർമ്മിക്കില്ല.

സിഗ്നേച്ചറുകൾ സാധാരണ രീതിയിൽ കണക്കാക്കുകയും എന്നാൽ അവഗണിക്കുകയും ചെയ്യുന്ന ഒരു സിഗ്നേച്ചർ രീതി
പുനർനിർമ്മിക്കണമോ എന്ന് തീരുമാനിക്കുമ്പോൾ വാസ്തുവിദ്യയുടെ ആശ്രിതത്വം. ഇത് ഉപയോഗപ്രദമാകും
യഥാർത്ഥത്തിൽ ആർക്കിടെക്ചർ-സ്വതന്ത്ര ഫയലുകൾ; നിലവിൽ നിങ്ങൾ ഒരു വാസ്തുവിദ്യയിൽ നിർമ്മിക്കുകയാണെങ്കിൽ,
നിങ്ങൾ മാറുമ്പോൾ ആർക്കിടെക്ചർ-സ്വതന്ത്ര ഫയലുകൾ പോലും പുനർനിർമ്മിക്കണമെന്ന് makepp നിർബന്ധിക്കും
മറ്റൊരു വാസ്തുവിദ്യയിലേക്ക്.

· ലാറ്റക്സ് ഫയലുകളിലെ കമൻ്റുകൾ എങ്ങനെ അവഗണിക്കാമെന്ന് അറിയാവുന്ന ഒരു സിഗ്നേച്ചർ രീതി
"c_compilation_md5" രീതിക്ക് C ഫയലുകളിലെ കമൻ്റുകൾ എങ്ങനെ അവഗണിക്കാമെന്ന് അറിയാം.

· ഓട്ടോമാറ്റിക് ഡോക്യുമെൻ്റേഷൻ എക്‌സ്‌ട്രാക്‌ഷനുള്ള ഒരു സിഗ്‌നേച്ചർ രീതി
ഒരു ഡോക്യുമെൻ്റേഷൻ എക്‌സ്‌ട്രാക്‌ടറിന് ആവശ്യമായ അഭിപ്രായങ്ങൾ ഉറവിടത്തിലെ മറ്റ് മാറ്റങ്ങൾ അവഗണിക്കുന്നു
ഫയൽ.

പൂർത്തിയാകാത്തത്
ഈ പ്രമാണം ഇതുവരെ പൂർത്തിയായിട്ടില്ല. നിങ്ങളുടെ സ്വന്തം സ്കാനറുകൾ എങ്ങനെ എഴുതാം എന്നതിനെ ഇത് ഉൾക്കൊള്ളുന്നു
ഫയലുകളും അതുപോലുള്ള കാര്യങ്ങളും ഉൾപ്പെടുത്തുക.

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