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

പട്ടിക:

NAME

makepp_builtins -- makepp-ലെ ബിൽറ്റിൻ കമാൻഡുകൾ

വിവരണം

A: ഉണരുക, C: &പൂച്ച,
chgrp,
&chmod,
ചൗൺ,
&cp,
സിപിപി,
&മുറിക്കുക, D: തീയതി, E: &എക്കോ,
&എക്സ്പ്രർ, F: തെറ്റായ,
fmt, G: &ഗ്രെപ്പ്, H: തല, I: &ഇൻസ്റ്റാൾ ചെയ്യുക, L: &ln, M: m4,
&mkdir,
&mv, P: &perl,
&മുൻപ്രോസസ്സ്,
&printf, R: &rm,
rm ആണ്, S: &സെഡ്,
& അടുക്കുക, T: വാൽ,
&ടെംപ്ലേറ്റ്,
&സ്പർശിക്കുക,
tr, U: &അൺഇൻസ്റ്റാൾ ചെയ്യുക,
&uniq, Y: &അതെ

ഒരു റൂളിൽ ബിൽറ്റ്-ഇൻ കമാൻഡുകൾ വിളിക്കാൻ ഒരു പ്രത്യേക ഷെൽ പോലെയുള്ള സാദ്ധ്യതയുണ്ട്. ഒരേയൊരു
കമന്റ് ചിഹ്നങ്ങൾ, ബാക്ക്‌സ്ലാഷുകൾ, സിംഗിൾ, ഡബിൾ ഉദ്ധരണികൾ എന്നിവയാണ് അംഗീകൃത മെറ്റാക്യാരാക്‌ടറുകൾ. മാത്രം
ഓരോ വരിയിലും ഒരു കമാൻഡ് നൽകാം, കൂടാതെ I/O റീഡയറക്ഷൻ ലഭ്യമല്ല ("-i", "-o" എന്നിവ കാണുക
പകരം താഴെ).

ഈ കമാൻഡുകൾ "&" എന്നതിൽ ആരംഭിക്കുന്നു, ഇത് Perl ലെ ഫംഗ്‌ഷൻ പ്രതീകമാണ്, സാധുതയുള്ളതല്ല
ഷെല്ലിലെ ആദ്യ കഥാപാത്രം. ആ പേരിന്റെ ബിൽട്ടിൻ കമാൻഡ് കണ്ടെത്താൻ കഴിയുന്നില്ലെങ്കിൽ, ഇതും
റൂൾ നടപ്പിലാക്കുന്ന Perl ഉദാഹരണത്തിനുള്ളിൽ ഒരു ബാഹ്യ സ്ക്രിപ്റ്റ് വിളിക്കുന്നതിനുള്ള വാക്യഘടന.
"ഓട്ടം" കാണുക.

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

ആദ്യ വാക്കുകൾ ;= $(&കട്ട് -ഡി' -f0 $(ഫയലുകൾ))

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

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

ഫയൽനാമങ്ങളുടെ ലിസ്‌റ്റുകൾ ശൂന്യമായേക്കാം, ഈ കമാൻഡുകൾ അൺചെക്ക് ചെയ്‌ത് വിളിക്കുന്നത് സുരക്ഷിതമാക്കുന്നു
പട്ടിക. അവയുടെ ഹ്രസ്വ രൂപത്തിലുള്ള ഓപ്‌ഷനുകൾ "-a -b" എന്നതിന് പകരം "-ab" പോലെ ഒട്ടിച്ചേക്കാം.
ദൈർഘ്യമേറിയ രൂപത്തിൽ ആർഗ്യുമെന്റുകൾ ഒന്നുകിൽ "=" ചിഹ്നം ഉപയോഗിച്ച് ഒട്ടിച്ചേക്കാം അല്ലെങ്കിൽ പ്രത്യേകം നൽകാം.
ഹ്രസ്വ രൂപത്തിൽ അവ നേരിട്ടോ വെവ്വേറെയോ ഒട്ടിച്ചേക്കാം.

സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ
ഹ്രസ്വ രൂപം ചിലപ്പോൾ മറഞ്ഞിരിക്കുമെങ്കിലും, നിരവധി ബിൽഡിനുകൾക്ക് ചില ഓപ്ഷനുകൾ സാധാരണമാണ്
ഒരു കമാൻഡിന്റെ സ്വന്തം ഓപ്ഷൻ ("&കട്ട് -f" പോലെ):

-A ഫയലിന്റെ പേര്
--args-file=ഫയലിന്റെ പേര്
--arguments-file=ഫയലിന്റെ പേര്
ഫയൽ വായിച്ച്, ഒരുപക്ഷേ ഉദ്ധരിച്ച വൈറ്റ്‌സ്‌പെയ്‌സ്- കൂടാതെ/അല്ലെങ്കിൽ പുതിയ ലൈൻ-വേർതിരിക്കപ്പെട്ടതായി പാഴ്‌സ് ചെയ്യുക
ഓപ്ഷനുകൾ.

-f
--ശക്തിയാണ്
മറ്റൊരു തരത്തിലാണെങ്കിലും, പരാമീറ്ററുകൾ ഉദ്ദേശിച്ചിട്ടുള്ള ഫയൽ(കൾ) സൃഷ്ടിക്കാൻ നിർബന്ധിക്കുക
ഫയലിന്റെ അല്ലെങ്കിൽ ആ പേരിന്റെ ശൂന്യമായ ഡയറക്ടറി ഇതിനകം നിലവിലുണ്ട്. ഇത് "-o,
--output=filename" എന്ന ഓപ്ഷൻ അതിൽ എന്തെങ്കിലും സ്വാധീനം ചെലുത്തണമെങ്കിൽ.

-i ഷെൽകമാൻഡ്
--inpipe=ഷെൽകമാൻഡ്
ഷെൽ കമാൻഡ്(കൾ) ആരംഭിച്ച് ഔട്ട്‌പുട്ട് ബിൽറ്റിനിലേക്ക് പൈപ്പ് ചെയ്യുക. ഓപ്ഷണലായി ഉണ്ടാകാം
"|" പിന്നിലായിരിക്കുക പ്രതീകം, ഇത് ഒരു പൈപ്പ് ആണെന്ന് സൂചിപ്പിക്കാൻ. ഈ ഓപ്ഷൻ ഉപയോഗിച്ച് നമ്പർ
ഫയലുകളുടെ പേരുകൾ നൽകേണ്ടതുണ്ട്. എന്നാൽ നിങ്ങൾക്ക് രണ്ട് ഫയലുകളിലും ബിൽട്ടിൻ നടത്തണമെങ്കിൽ
പൈപ്പ് ഔട്ട്പുട്ട്, നിങ്ങൾ പൈപ്പ് ഔട്ട്പുട്ടിന്റെ ഫയൽനാമമായി "-" ഉപയോഗിക്കണം. പൈപ്പ് ആണ്
ശൂന്യമാണ്, പക്ഷേ, നിങ്ങൾ "--infail" എന്നതും നൽകിയില്ലെങ്കിൽ, കമാൻഡ് കാത്തിരിക്കില്ല, അതിനാൽ അത്
സമാന്തരമായി അവസാനിപ്പിക്കാം. റീഡയറക്ഷൻ ഇല്ലാത്തതിനാൽ ഈ ഓപ്ഷൻ ആവശ്യമാണ്
വാക്യഘടന.

-I
--പരാജയം
ഒരു "--inpipe" ഷെൽ കമാൻഡ് പരാജയപ്പെടുകയാണെങ്കിൽ, അത് നിലവിലെ ബിൽറ്റിൻ പരാജയപ്പെടുന്നതിന് കാരണമാകുന്നു.
സ്ട്രോബെറിയിലും വിൻ ആക്റ്റീവ്സ്റ്റേറ്റിലും ഇത് നിലവിൽ പ്രവർത്തിക്കുന്നില്ല, കാരണം
അർദ്ധഹൃദയത്തോടെ അവർ Unix fork/exec അനുകരിക്കുന്നു. സിഗ്വിൻ അത് ശരിയാക്കുന്നു.

-o ഫയലിന്റെ പേര്
--ഔട്ട്‌പുട്ട്=ഫയലിന്റെ പേര്
stdout-ന് പകരം ഈ ഫയലിലേക്ക് ഔട്ട്പുട്ട് എഴുതുക. ഫയലിന്റെ പേരിൽ ഇവയിലേതെങ്കിലും ഉണ്ടായിരിക്കാം
ഫോമുകൾ:

ഫയലിന്റെ പേര്
>ഫയലിന്റെ പേര്
ഫയലിലേക്ക് എഴുതുക.

>>ഫയലിന്റെ പേര്
നിലവിലുള്ള ഫയലിലേക്ക് കൂട്ടിച്ചേർക്കുക (ആവശ്യമില്ല).

+<ഫയലിന്റെ പേര്
ഇൻ‌പുട്ടിനായി ഫയൽ തുറക്കുക, ഇൻ‌പ്ലേസ് എഡിറ്റിംഗ് അനുവദിക്കുന്നു. ഈ ഓപ്ഷൻ വേരിയന്റിനൊപ്പം
ഇൻപുട്ട് ഫയൽനാമങ്ങൾ നൽകേണ്ടതില്ല. എന്നാൽ നിങ്ങൾ ബിൽഡിൻ നിർവഹിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ
കൂടുതൽ ഫയലുകൾ, ഇതിനുള്ള ഒരു ഇൻപുട്ട് ഫയൽനാമമായി നിങ്ങൾ "-" ഉപയോഗിക്കണം. വാസ്തവത്തിൽ ദി
ഔട്ട്പുട്ട് ഒരു താൽക്കാലിക ഫയലിലേക്ക് എഴുതപ്പെടും, അത് അവസാനം ഫയലിന്റെ പേരിലേക്ക് മാറ്റും.

|ഷെൽകമാൻഡ്
ഷെൽ കമാൻഡിലേക്ക്(കളിലേക്ക്) ബിൽറ്റിൻ ഔട്ട്പുട്ട് പൈപ്പ് ചെയ്യുക.

റീഡയറക്ഷൻ സിന്റാക്സ് ഇല്ലാത്തതിനാൽ ഈ ഓപ്ഷൻ ആവശ്യമാണ്.

-O
--പരാജയം
ഒരു "--ഔട്ട്‌പുട്ട്" ഷെൽ കമാൻഡ് പരാജയപ്പെടുകയാണെങ്കിൽ, അത് നിലവിലെ ബിൽട്ടിൻ പരാജയപ്പെടുന്നതിന് കാരണമാകുന്നു.

-r അക്കം
--record-size=അക്കം
നിലവിലെ ബിൽറ്റിന് വേണ്ടി പ്രാദേശികമായി $/ സജ്ജീകരിക്കുന്നു. ഇത് ഇൻപുട്ടിനെ ദൈർഘ്യത്തിന്റെ റെക്കോർഡുകളായി വിഭജിക്കുന്നു
അക്കം അല്ലാതെ വരി വരിയായി. എങ്കിൽ അക്കം പൂജ്യമാണ്, ഓരോ ഇൻപുട്ട് ഫയലും മൊത്തത്തിൽ ഒന്നാണ്
റെക്കോർഡ്.

-s സ്ട്രിംഗ്
--separator=സ്ട്രിംഗ്
നിലവിലെ ബിൽറ്റിന് വേണ്ടി പ്രാദേശികമായി $/ സജ്ജീകരിക്കുന്നു. ഇത് ഇൻപുട്ട് വിഭജിക്കുന്നു സ്ട്രിംഗ് പകരം വരി
വരി വഴി.

-S
--സമന്വയങ്ങൾ
"#ലൈൻ" സൃഷ്ടിക്കുക"ഇല്ല"""""ഫയൽ"""", "#ലൈൻ""ഇല്ല" പല സി-ലൈക്കും മനസ്സിലാക്കിയ വരികൾ
ഭാഷകൾ.

-v
--വാക്കുകൾ
ഫയൽ സിസ്റ്റത്തിലെ മാറ്റങ്ങൾ രേഖപ്പെടുത്തുക. ഇത് വേണമെങ്കിൽ മറ്റ് ഓപ്ഷനുകൾക്ക് മുമ്പായിരിക്കണം
അവയുടെ പ്രഭാവം രേഖപ്പെടുത്തുക. നിങ്ങൾ makepp-ലേക്ക് തന്നെ ഈ ഓപ്ഷൻ നൽകിയാൽ, അത് നിങ്ങൾക്ക് ഉണ്ടായിരുന്നത് പോലെയാണ്
ഓരോ ബിൽറ്റിൻ കമാൻഡിനും ഇത് നൽകിയിരിക്കുന്നു.

ബിൽറ്റിൻ കമാൻഡുകൾ
makepp-ൽ ബിൽട്ടിൻ കമാൻഡുകൾ ഉണ്ടാകുന്നതിന് രണ്ട് പ്രചോദനങ്ങളുണ്ട്. ആദ്യത്തേത് എ വാഗ്ദാനം ചെയ്യുക എന്നതാണ്
ഷെൽ കമാൻഡുകളിൽ നിന്ന് വ്യത്യസ്തമായി, ഒരേപോലെ പ്രവർത്തിക്കുമെന്ന് ഉറപ്പുനൽകുന്ന യൂട്ടിലിറ്റികളുടെ ഒരു കൂട്ടം
എല്ലായിടത്തും, "&echo -n" അല്ലെങ്കിൽ "&mkdir -p" പോലെ, പാത കണ്ടെത്തുന്നതിനുള്ള ബുദ്ധിമുട്ട് നിങ്ങളെ സംരക്ഷിക്കുന്നു
അതിന്റെ വ്യത്യസ്‌തമായ ഓപ്ഷനുകൾ &ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനും കണ്ടെത്തുന്നതിനും. ഒരു സമാഹാര പരിതസ്ഥിതിയിൽ,
സാധാരണയായി "m4" മാത്രം നൽകുന്ന "--synclines" ഓപ്ഷൻ ഉണ്ടായിരിക്കുന്നത് ഉപയോഗപ്രദമാണ്.
ഫിൽട്ടറുകൾ.

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

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

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

sub my_filter {
# $_ എന്നത് ശരിയാണെങ്കിൽ റിട്ടേൺ ചെയ്യുക
}
%.out: %.in Makeppfile
&grep &my_filter $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

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

മറുവശത്ത്, നിങ്ങൾക്ക് പ്രോഗ്രാമാറ്റിക് മിക്സ് ചെയ്യുന്ന ഒരു പ്രോഗ്രാം ഉണ്ടെങ്കിൽ അജ്ഞത അഭികാമ്യമാണ്
ഒരു ഫയലിൽ കോൺഫിഗറേഷൻ വശങ്ങളും. രണ്ടും അടങ്ങുന്ന ഒരു WSDL ഫയലാണ് ഒരു ഉദാഹരണം
വെബ് സേവന ഇന്റർഫേസ് നിർവചനവും ഒരു IP വിലാസവും. നിങ്ങൾക്ക് ഈ ഫയൽ മുൻകൂട്ടി പ്രോസസ്സ് ചെയ്യാം
കോൺഫിഗറേഷനിൽ പാച്ച് ചെയ്യാനുള്ള &ടെംപ്ലേറ്റ് കമാൻഡ്, പക്ഷേ makepp നോട്ടീസ് അനുവദിക്കരുത്.

&പൂച്ച [ഓപ്ഷൻ ...] ഫയലിന്റെ പേര് ...
എല്ലാ ഫയലുകളും ഒരൊറ്റ ഒന്നായി സംയോജിപ്പിക്കുന്നു.

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=ഫയലിന്റെ പേര്, -f, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=filename, -O, --outfail, -S,
--synclines, -v, --verbose"

&chmod [ഓപ്ഷൻ ...] മോഡ് ഫയലിന്റെ പേര് ...
സജ്ജമാക്കുന്നു മോഡ് നൽകിയിരിക്കുന്ന എല്ലാ ഫയലുകൾക്കും. മോഡ് ഒരു ഒക്ടൽ സ്ട്രിംഗ് ആയിരിക്കണം.

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=filename, -v, --verbose"

&cp [ഓപ്ഷൻ ...] ഉറവിട ഫയൽ destfile
&cp [ഓപ്ഷൻ ...] ഉറവിട ഫയൽ
&cp [ഓപ്ഷൻ ...] ഉറവിട ഫയൽ ... destdir
പകര്പ്പ് ഉറവിട ഫയൽ ലേക്ക് destfile, ഒന്ന് ഉറവിട ഫയൽ നിലവിലെ ഡയറക്ടറി അല്ലെങ്കിൽ ഒന്നിലധികം
ഉറവിട ഫയൽs ടു destdir അതേ പേരിൽ.

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=ഫയലിന്റെ പേര്, -f, --force, -v,
--വാക്കുകൾ"

-l
--ലിങ്ക്
ഫയലുകൾ ലിങ്ക് ചെയ്യാൻ ശ്രമിക്കുക. അത് പരാജയപ്പെടുകയാണെങ്കിൽ, പ്രതീകാത്മക ലിങ്ക് പരീക്ഷിക്കുക, അതും ആണെങ്കിൽ
അഭ്യർത്ഥിച്ചു, അല്ലെങ്കിൽ പകർത്തുക.

-s
--പ്രതീകാത്മകം
--സിംബോളിക്-ലിങ്ക്
--സിംലിങ്ക്
ഫയലുകൾ പ്രതീകാത്മകമായി ലിങ്ക് ചെയ്യാൻ ശ്രമിക്കുക. അത് പരാജയപ്പെട്ടാൽ, പകർത്തുക.

&ln എന്നതിന് താഴെയുള്ള കുറിപ്പ് കാണുക.

&മുറിക്കുക [ഓപ്ഷൻ ...] ഫയലിന്റെ പേര് ...
ഓരോ ഫയലിൽ നിന്നോ തിരഞ്ഞെടുത്ത വരികളിൽ നിന്നോ തിരഞ്ഞെടുത്ത വരികളുടെ ഭാഗങ്ങൾ പ്രിന്റ് ചെയ്യുക, എല്ലായിടത്തും എണ്ണുക
ഫയലുകൾ. ഫീൽഡുകൾക്കും ഫീൽഡുകൾക്കുമായി TAB-ലേക്ക് ഡിഫോൾട്ട് ചെയ്യുന്ന ഡിലിമിറ്റർ ഉപയോഗിച്ച് ഔട്ട്പുട്ട് വേർതിരിക്കുന്നു
പ്രതീകങ്ങൾക്കായി ശൂന്യമായ സ്ട്രിംഗ്.

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=ഫയലിന്റെ പേര്, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=filename, -O, --outfail, -r,
--record-size=number, --separator=string, -S, --synclines, -v, --verbose"

-c പട്ടിക
--അക്ഷരങ്ങൾ=പട്ടിക
വ്യക്തമാക്കിയ എല്ലാ പ്രതീകങ്ങളും പ്രിന്റ് ചെയ്യുക പട്ടിക. പട്ടിക ഏതെങ്കിലും പേൾ എക്സ്പ്രഷൻ ആയിരിക്കാം
പൂർണ്ണസംഖ്യകളുടെ ഒരു ലിസ്റ്റ് തിരികെ നൽകുന്നു. പൂർണ്ണസംഖ്യകൾ ഒന്നുകിൽ പോസിറ്റീവ് ആകാം
ആദ്യം മുതൽ എണ്ണാൻ പൂജ്യം, അല്ലെങ്കിൽ അവസാനം മുതൽ എണ്ണാൻ നെഗറ്റീവ്. Unix പോലെയല്ല
"കട്ട്", നിങ്ങൾ അഭ്യർത്ഥിക്കുന്ന ഓർഡർ മാനിക്കപ്പെടുന്നു.

പെർളിന്റെ സ്ലൈസ് ഓപ്പറേറ്ററിൽ നിന്ന് വ്യത്യസ്തമായി ".." ശ്രേണി പോസിറ്റീവ് ആയിരിക്കണം അല്ലെങ്കിൽ
നെഗറ്റീവ്, &കട്ട് പോസിറ്റീവിൽ തുടങ്ങി നെഗറ്റീവിൽ അവസാനിക്കാൻ അനുവദിക്കുന്നു. പക്ഷേ
നിങ്ങളുടെ എക്‌സ്‌പ്രഷനിൽ അക്കങ്ങളും കോമകളും മാത്രമേ ഉള്ളൂ എങ്കിൽ മാത്രമേ ഇത് ലഭ്യമാകൂ
"..". ഉദാ "1..-2" എന്നാൽ ആദ്യത്തേതും (0) അവസാനത്തേതും (-1) ഒഴികെ എല്ലാം അർത്ഥമാക്കുന്നു.

ലിസ്‌റ്റ് എക്‌സ്‌പ്രഷനു മുഴുവൻ വരിയും $_-ൽ കാണാൻ കഴിയും. അതിനുള്ള മാറ്റങ്ങളുണ്ടാകും
എന്നിരുന്നാലും, അവഗണിച്ചു, കാരണം ഈ പദപ്രയോഗം വിലയിരുത്തുമ്പോൾ വരി ഇതിനകം തന്നെ ഉണ്ട്
പേളിന്റെ ഓട്ടോസ്പ്ലിറ്റ് വേരിയബിളിലേക്ക് വിഭജിക്കപ്പെട്ടിരിക്കുന്നു @::F. നിങ്ങൾ തിരികെ നൽകുന്ന സംഖ്യകൾ യഥാർത്ഥമാണ്
ആ പട്ടികയിലെ സൂചികകൾ.

-d സ്ട്രിംഗ്
--ഡിലിമിറ്റർ=സ്ട്രിംഗ്
ഇൻപുട്ട് ഫീൽഡുകൾക്കും ഔട്ട്പുട്ടിനുമായി ഒരു പുതിയ ഡിലിമിറ്റർ സജ്ജമാക്കുക. Unix "കട്ട്" പോലെയല്ല, ഇത് ഉണ്ടായിരിക്കാം
ഏതെങ്കിലും നീളം.

-E
--രക്ഷയില്ല
"-p, --printf=format" എന്നതിന് "\" സാധാരണ അക്ഷരങ്ങളായി പരിഗണിക്കുക.

-f പട്ടിക
--ഫീൽഡുകൾ=പട്ടിക
വ്യക്തമാക്കിയ എല്ലാ ഗ്രൂപ്പുകളും പ്രിന്റ് ചെയ്യുക പട്ടിക. പട്ടിക "-c, താഴെ വിവരിച്ചിരിക്കുന്നത് പോലെയാണ്
--characters=list". ഇത് "-f" എന്ന സ്റ്റാൻഡേർഡ് ഓപ്‌ഷൻ മറയ്ക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക
"--ഫോഴ്സ്" ആയി നൽകിയിരിക്കുന്നു.

-l പട്ടിക
--വരികൾ=പട്ടിക
വ്യക്തമാക്കിയ എല്ലാ വരികളും പ്രിന്റ് ചെയ്യുക പട്ടിക. പട്ടിക "-c, താഴെ വിവരിച്ചിരിക്കുന്നത് പോലെയാണ്
--characters=list" ഒരു പ്രധാന വ്യത്യാസം: ആദ്യ വരിയിൽ നമ്പർ 1 ഉണ്ട്, അവിടെ
വരി 0 അല്ല. നിങ്ങൾക്ക് ഒരു മിക്സഡ് ഉണ്ടെങ്കിൽ, വലിയ ഫയലുകൾക്ക് ഇത് തീർച്ചയായും കാര്യക്ഷമമല്ല
നിങ്ങളുടെ ലിസ്റ്റിലെ പോസിറ്റീവ് മുതൽ നെഗറ്റീവ് ശ്രേണി, അത് എല്ലാം മെമ്മറിയിലേക്ക് വായിക്കുന്നു.
അല്ലെങ്കിൽ പേളിന് ഇത് ഒപ്റ്റിമൈസ് ചെയ്യാൻ കഴിയും, പക്ഷേ അങ്ങനെയാണോ എന്ന് എനിക്കറിയില്ല.

-m
--പൊരുത്തം
പൊരുത്തപ്പെടുന്ന വരികൾ മാത്രം പ്രിന്റ് ചെയ്യുക, അതായത് മതിയായ പ്രതീകങ്ങളോ ഫീൽഡുകളോ ഉള്ളവ. ഈ
"-ഒൺലി-ഡീലിമിറ്റഡ്" എന്ന് സൂചിപ്പിക്കുന്നു, അതിനാലാണ് നിങ്ങൾക്ക് സിംഗിൾ-ഫീൽഡ് ലൈനുകൾ നഷ്‌ടമാകുന്നത്
"--ഫീൽഡുകൾ=0".

-p ഫോർമാറ്റ്
--printf=ഫോർമാറ്റ്
എല്ലാ ഫീൽഡുകളിലേക്കും പ്രതീകങ്ങളിലേക്കും ഫോർമാറ്റ് (\escapes ഉള്ളത്) പ്രയോഗിക്കുക.

-s
--മാത്രം-ഡീലിമിറ്റഡ്
ഡിലിമിറ്ററുകൾ അടങ്ങിയ വരികൾ മാത്രം പ്രിന്റ് ചെയ്യുക.

&കട്ട് -സി 10-20,-5,25- $(ഇൻപുട്ട്)
&cut -c 'grep $$_ % 3, 0..99' $(ഇൻപുട്ട്) # 1st 100 നിരകൾ 3 ന്റെ ഗുണിതമല്ല
&cut -d: --fields 0,4 --printf='%10s ആണ് %s\n' / etc / passwd

&എക്കോ [ഓപ്ഷൻ ...] സ്ട്രിംഗ് ...
&printf [ഓപ്ഷൻ ...] ഫോർമാറ്റ് വാദം ...
&അതെ [ഓപ്ഷൻ ...] സ്ട്രിംഗ് ...
എല്ലാ സ്ട്രിംഗുകളും stdout-ലേക്കോ തന്നിരിക്കുന്ന ഔട്ട്‌ഫയിലേക്കോ എഴുതുന്നു. &എക്കോയും &അതെയും ഒരു പുതിയ ലൈൻ ചേർക്കുക
അവസാനം. സ്ട്രിംഗുകൾ അല്ലെങ്കിൽ ഫോർമാറ്റ് &പ്രിന്റ്ഫ് എന്നതിനായി, "\" എസ്കേപ്പുകൾ അടങ്ങിയിരിക്കാം
സി അല്ലെങ്കിൽ ആധുനിക യുണിക്സ് അല്ലെങ്കിൽ ഷെൽ "എക്കോ" എന്നിവയിൽ നിന്നാണ് അറിയപ്പെടുന്നത്. എന്നിരുന്നാലും അവ പേൾ ഡബിൾ പോലെയാണ്-
ഉദ്ധരണികൾ, അതായത് ചില വ്യത്യാസങ്ങൾ, "\" എന്ന ഒറ്റ ട്രെയിലിംഗ് അനുവദനീയമല്ല.
പേളിന് രസകരമായ കുറച്ച് രക്ഷപ്പെടലുകൾ ഉണ്ട്, എന്നാൽ നിങ്ങൾ എന്തെങ്കിലും ചെയ്യാൻ പ്രതീക്ഷിക്കുന്നവ
വ്യത്യസ്തമാണ്:

\cA ഒരു നിയന്ത്രണ പ്രതീകമാണ് ^A.

\u ഇനിപ്പറയുന്ന അക്ഷരം അപ്കേസ് ചെയ്യുന്നു.

\U ബാക്കിയുള്ളവ, അല്ലെങ്കിൽ അടുത്ത "\E" അല്ലെങ്കിൽ "\L" വരെ കണ്ടെത്തുകയാണെങ്കിൽ.

\xHH, \x{HHHH}
നൽകിയിരിക്കുന്ന Hex കോഡിന്റെ പ്രതീക മൂല്യമാണ്. സംഖ്യാ കോഡുകൾ അല്ല എന്നത് ശ്രദ്ധിക്കുക
EBCDIC പ്ലാറ്റ്‌ഫോമുകളിലേക്ക് പോർട്ടബിൾ!

Unix "yes" എന്നതിൽ നിന്ന് വ്യത്യസ്തമായി, &yes എന്നത് &എക്കോ പോലെയാണ്, അത് ഔട്ട്പുട്ട് ആവർത്തിക്കുന്നു എന്നതൊഴിച്ചാൽ
കഴിയുന്നിടത്തോളം, സാധാരണയായി ഒരു "--ഔട്ട്‌പുട്ട് '| കമാൻഡ്'" അവസാനിപ്പിക്കുന്നു. ഒപ്പം, &അതെ എങ്കിൽ
ആർഗ്യുമെന്റുകളൊന്നുമില്ല, അത് "y" എന്നതിലേക്ക് സ്ഥിരസ്ഥിതിയായി മാറുന്നു.

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=ഫയലിന്റെ പേര്, -f, --force, -o,
--output=ഫയലിന്റെ പേര്, -O, --outfail, -v, --verbose"

-E
--രക്ഷയില്ല
"\" സാധാരണ അക്ഷരങ്ങളായി പരിഗണിക്കുക.

-n
--ന്യൂലൈൻ
അവസാന സ്ട്രിംഗിന് ശേഷം ഒരു പുതിയ വരി ചേർക്കരുത്. (&printf-ന് മനസ്സിലായില്ല.)

&expr [ഓപ്ഷൻ ...] പെർൽകോഡ് ...
perlcode-ന്റെ സ്കെയിലർ മൂല്യം പ്രിന്റ് ചെയ്യുക, അത് ഒന്നോ അതിലധികമോ ആർഗ്യുമെന്റുകളായി എഴുതാം.
ബിൽറ്റ്ഇൻ കമാൻഡുകൾ ഷെൽ പാഴ്‌സ് ചെയ്യുന്നില്ല എന്നത് ശ്രദ്ധിക്കുക, അതിനാൽ "*", "(" അല്ലെങ്കിൽ ">" അല്ല
പ്രത്യേകം. എന്നാൽ സ്ട്രിംഗ് ഉദ്ധരണികൾ makepp പാഴ്‌സ് ചെയ്യുന്നു, അതിനാൽ പേൾ സ്ട്രിംഗുകൾ ഉദ്ധരിക്കേണ്ടതാണ്
രണ്ട് തവണ, നിങ്ങൾക്ക് നഗ്നപദങ്ങൾ ഉപയോഗിക്കാൻ താൽപ്പര്യമില്ലെങ്കിൽ. മൂല്യം തെറ്റാണെങ്കിൽ, ഇത് പരാജയപ്പെടും. കുറിപ്പ്
അത് -- Unix "expr"-ൽ നിന്ന് വ്യത്യസ്തമായി -- Perl's index function 0-ൽ (false) ആരംഭിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു
പരാജയത്തിന് -1 (ശരി).

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=ഫയലിന്റെ പേര്, -f, --force, -o,
--output=ഫയലിന്റെ പേര്, -O, --outfail, -v, --verbose"

-n
--ന്യൂലൈൻ
ഔട്ട്പുട്ടിന് ശേഷം ഒരു പുതിയ ലൈൻ ചേർക്കരുത്.

&expr ($(VAR) - 3) * 2 < 1 && -1 || 1
&expr "$(VAR) - 3 * 2 < 1 ? 'joy' : 'sorrow'" -o $(ഔട്ട്‌പുട്ട്)
-&expr $(VAR) - 3 * 2 -o >>$(ഔട്ട്‌പുട്ട്)

&ഗ്രെപ്പ് [ഓപ്ഷൻ ...] പെർൽകോഡ് ഫയലിന്റെ പേര് ...
&perl [ഓപ്ഷൻ ...] പെർൽകോഡ് ഫയലിന്റെ പേര് ...
&സെഡ് [ഓപ്ഷൻ ...] പെർൽകോഡ് ഫയലിന്റെ പേര് ...
എല്ലാ ഫയലുകളും വരി വരിയായി വായിക്കുന്നു (നിങ്ങൾ "--സെപ്പറേറ്റർ" ഓപ്ഷൻ നൽകിയില്ലെങ്കിൽ), കൂടാതെ
പെർൽകോഡ് ഓരോ വരിയും പ്രിന്റ് ചെയ്യപ്പെടുന്നതിന് മുമ്പ് അത് വിലയിരുത്തപ്പെടുന്നു. &sed സമാനമാണ്
"perl -pe", അതേസമയം &grep ആ വരികൾ മാത്രമേ ഔട്ട്പുട്ട് ചെയ്യുന്നുള്ളൂ പെർൽകോഡ് ഒരു സത്യം തിരികെ നൽകുന്നു
മൂല്യം. &perl "perl -ne" ന് സമാനമാണ്, നിങ്ങൾ വ്യക്തമായി പ്രിന്റ് ചെയ്യുന്നതെന്തും ഔട്ട്പുട്ട് ചെയ്യുന്നു
ലെ പെർൽകോഡ്. ലൈൻ ഉള്ളടക്കം $_-ൽ ലഭ്യമാണ്, അത് പരിഷ്‌ക്കരിച്ചേക്കാം.

ഈ മൂന്നിൽ, ഒന്നും ഔട്ട്പുട്ട് ചെയ്തില്ലെങ്കിൽ &grep പരാജയപ്പെടും. ഇല്ല എന്നത് ശ്രദ്ധിക്കുക
അവഗണിക്കുക-കേസ് ഓപ്ഷൻ, കാരണം നിങ്ങൾ അത് "/ ഉപയോഗിച്ച് ചെയ്യുംregexp/i".

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=ഫയലിന്റെ പേര്, -f, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=filename, -O, --outfail, -r,
--record-size=number, -s, --separator=string, -S, --synclines, --verbose"

നിങ്ങൾ &Mpp::Cmds::print to ഉപയോഗിക്കുകയാണെങ്കിൽ, "--synclines" എന്ന ഓപ്‌ഷൻ &perl-ന് മാത്രമേ അർത്ഥമുള്ളൂ
ഔട്ട്പുട്ട് $_. &grep-ന് മാത്രമേ അധിക ഓപ്ഷനുകൾ ഉള്ളൂ:

-c
--എണ്ണം
സാധാരണ ഔട്ട്പുട്ട് അടിച്ചമർത്തുക; പകരം പൊരുത്തപ്പെടുന്ന വരികളുടെ എണ്ണം പ്രിന്റ് ചെയ്യുക. "-v ഉപയോഗിച്ച്,
--invert-match" ഓപ്ഷൻ (ചുവടെ കാണുക), പൊരുത്തപ്പെടാത്ത വരികൾ എണ്ണുക.

-l
--ലിസ്റ്റ്
--files-with-matchs
പൊരുത്തമുള്ള ഫയലുകളുടെ പേര് മാത്രം ഔട്ട്പുട്ട് ചെയ്യുക. ഇത് "-v എന്നതുമായി സംയോജിപ്പിക്കുമ്പോൾ,
--invert-match", പൊരുത്തപ്പെടാത്ത ലൈനുകളുള്ള ഫയലുകളുടെ പേര് ഔട്ട്പുട്ട് ചെയ്യുക (ഒരു ബിറ്റ്
അസംബന്ധമായും എന്നാൽ Unix -vl മായി പൊരുത്തപ്പെടുന്നു). ഇത് ഇരട്ടിയായി കൂടിച്ചേർന്നാൽ
"-vv", പൊരുത്തങ്ങളില്ലാത്ത ഫയലുകളുടെ പേര് ഔട്ട്പുട്ട് ചെയ്യുക.

-v
--വിപരീതമായി
--മാച്ച്-മാച്ച്
--ഇൻവർട്ട്-മാച്ച്
പൊരുത്തപ്പെടാത്ത വരികൾ തിരഞ്ഞെടുക്കുന്നതിന്, പൊരുത്തപ്പെടുന്ന ബോധം വിപരീതമാക്കുക. ഇത് മറയ്ക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക
സ്റ്റാൻഡേർഡ് ഓപ്ഷൻ "-v" അത് "--verbose" ആയി നൽകണം.

-w ഫയലിന്റെ പേര്
--waste-file=ഫയലിന്റെ പേര്
നിരസിച്ച ലൈനുകൾ ശേഖരിക്കുന്നതിനുള്ള ഒരു ഓപ്ഷണൽ വേസ്റ്റ് ബാസ്കറ്റ്. ഇത് വേണ്ടി മാത്രമല്ല
നിങ്ങളുടെ സെലക്ഷൻ കോഡ് ഡീബഗ്ഗുചെയ്യുന്നു, മാത്രമല്ല നിങ്ങളുടെ ഇൻപുട്ട് രണ്ടായി വിഭജിക്കുന്നതിനും. ഉള്ളതുപോലെ
സാധാരണ ഔട്ട്‌പുട്ട്, നിങ്ങൾ $_ എന്നതിൽ തെറ്റ് നൽകുന്നതിന് മുമ്പ് മാറ്റം വരുത്താം.

&sed s/foo/bar/ f1 f2 f3 -o outfile # പോലെ sed s/foo/bar/ f1 f2 f3 >outfile
&sed '$$_ = uc' f1 f2 f3 -o outfile # പോലെ tr '[:lower:]' '[:upper:]' f1 f2 f3
&grep '$$. % 3' f1 f2 f3 -o outfile # ഓരോ മൂന്നാം വരിയും ഒഴിവാക്കുക
&grep -c /match/i f1 f2 f3 # STDOUT-ലേക്ക് 'പൊരുത്ത'വുമായി പൊരുത്തപ്പെടുന്ന വരികൾ എണ്ണുക

മാസ് ജനറേറ്റ് ആക്‌സസറുകളിലേക്ക് നിങ്ങളെ പ്രേരിപ്പിക്കാതെ, ലളിതമായി നിങ്ങൾക്കത് എങ്ങനെ ചെയ്യാമെന്നത് ഇതാ
ഓരോ തരത്തിനും ആവശ്യമുള്ള വേരിയബിൾ നാമത്തിനും ഇടയിൽ RO അല്ലെങ്കിൽ RW യുടെ ഒരു അഭിപ്രായം ഇടുന്നു, എല്ലാം ഒന്നിൽ
ലൈൻ. ജനറേറ്റ് ചെയ്‌ത ഗെറ്ററും ഓപ്‌ഷണലായി സെറ്റർ രീതികളും അടുത്തതായി കണ്ടെത്തിയവയിലേക്ക് പോകുന്നു
പൊതു അല്ലെങ്കിൽ സംരക്ഷിത വിഭാഗം:

# "ടൈപ്പ് /* R[OW] */ അംഗം;" എന്നതിൽ നിന്ന് നേടുകയും സജ്ജമാക്കുകയും ചെയ്യുക.
ഉപ cxx_accessors {
$acc ||= ''; # 5.10.0 സംസ്ഥാനത്തെ സ്ഥാനാർത്ഥി
if( m!^\s*(.+?)\s*/\*\s*R([OW])\s*\*/\s*(.+?)\s*;! ) {
$acc .= "#ലൈൻ $.\n"; # ഇത് എവിടെ നിന്നാണ് വന്നതെന്ന് C++ പറയുക
$acc .= "അസാധുവായ സെറ്റ്\u$3( $1 &__tmp ) {$3 = __tmp; }"
$2 eq 'W' ആണെങ്കിൽ;
$acc .= "$1 &get\u$3() const {$3 തിരികെ നൽകുക; }\n";
} elsif( /^\s*(?:public|സംരക്ഷിത)\s*:/ ) {
$_ .= $acc;
$acc = '';
}
}

%.cc: %.cc.in # I/O കൈകാര്യം ചെയ്യുന്നതിന് &sed ഉപയോഗിക്കുക
&sed --sync-lines &cxx_accessors $(input) -o $(output)

&ഇൻസ്റ്റാൾ ചെയ്യുക [ഓപ്ഷൻ ...] ഉറവിട ഫയൽ destfile
&ഇൻസ്റ്റാൾ ചെയ്യുക [ഓപ്ഷൻ ...] ഉറവിട ഫയൽ ... destdir
&ഇൻസ്റ്റാൾ --ഡയറക്‌ടറി [ഓപ്ഷൻ ...] ഡയറക്ടറി ...
നീക്കുക അല്ലെങ്കിൽ പേരുമാറ്റുക ഉറവിട ഫയൽ ലേക്ക് destfile, അല്ലെങ്കിൽ ഒന്നിലധികം ഉറവിട ഫയൽs ടു destdir കൂടെ
അതേ പേര്. ബിൽഡ് ഫലങ്ങൾ അവയുടെ അന്തിമഫലത്തിലേക്ക് മാറ്റുന്നതിനുള്ള തിരഞ്ഞെടുത്ത മാർഗമാണിത്
ഇൻസ്റ്റലേഷൻ സ്ഥലങ്ങൾ.

&ഇൻസ്റ്റാൾ ചെയ്യുന്ന എല്ലാ ഫയൽ സിസ്റ്റം പരിഷ്ക്കരണവും അതിന്റെ അവസാനം ലോഗ് ചെയ്യപ്പെടും
എൻവയോൺമെന്റ് വേരിയബിൾ $INSTALL_LOG ചൂണ്ടിക്കാണിച്ച ഫയൽ, അല്ലെങ്കിൽ, അത് സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ പക്ഷേ
ഞങ്ങൾ ഒരു ഡയറക്‌ടറിയുടെ കീഴിലാണ് RootMakeppfile(.mk), എന്ന ഫയലിലേക്ക് .install_log അതിൽ
ഡയറക്ടറി, അല്ലെങ്കിൽ നിലവിലെ ഡയറക്‌ടറിയിലെ ആ ഫയലിലേക്ക്. നിങ്ങൾ ഇല്ലാതാക്കാൻ ആഗ്രഹിച്ചേക്കാം
ഇൻവോക്കേഷനുകളുടെ ഒരു ശ്രേണിക്ക് മുമ്പായി ലോഗ്ഫയൽ &ഇൻസ്റ്റാൾ ചെയ്യുക.

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=filename, -v, --verbose"

-c
--പകർപ്പ്
ഫയലുകൾ നീക്കുന്നതിന് പകരം അവ പകർത്തുക. നിർബന്ധിക്കാത്തതിനാൽ ഇത് അഭികാമ്യമാണ്
അടുത്ത തവണ ഫയൽ പുനർനിർമ്മിക്കാൻ makepp. എന്നാൽ ഇത് സ്ഥിരസ്ഥിതിയല്ല, കാരണം
മറ്റ് ഇൻസ്റ്റാൾ പ്രോഗ്രാമുകളുമായുള്ള അനുയോജ്യത.

-d
--ഡയറക്‌ടറി
ഈ കമാൻഡിന്റെ മൂന്നാം ഫോമിൽ നൽകിയിരിക്കുന്ന എല്ലാ ഡയറക്‌ടറികളും മറ്റേതെങ്കിലും സൃഷ്‌ടിക്കുക
ആവശ്യമായ പാരന്റ് ഡയറക്ടറികൾ.

-g ഗ്രൂപ്പ്
--ഗ്രൂപ്പ്=ഗ്രൂപ്പ്
ലക്ഷ്യസ്ഥാന ഫയലുകളുടെ ഗ്രൂപ്പ് ഉടമസ്ഥാവകാശം മാറ്റുക. ഗ്രൂപ്പ് നൽകിയേക്കാം
പേര് അല്ലെങ്കിൽ സംഖ്യാപരമായി.

-l
--ലിങ്ക്
ഫയലുകൾ ലിങ്ക് ചെയ്യാൻ ശ്രമിക്കുക. അത് പരാജയപ്പെട്ടാൽ, പകർത്തുക.

--log=ഫയലിന്റെ പേര്
--logfile=ഫയലിന്റെ പേര്
ഉപയോഗം ഫയലിന്റെ പേര് സാധാരണ ലോഗ്ഫയലിന് പകരം.

-m മോഡ്
--മോഡ്=മോഡ്
സജ്ജമാക്കുന്നു മോഡ് എല്ലാ ലക്ഷ്യസ്ഥാന ഫയലുകൾക്കും ഡയറക്‌ടറികൾക്കും. മോഡ് ഒരു ഒക്ടൽ സ്ട്രിംഗ് ആയിരിക്കണം.

-o ഉടമ
--ഉടമ=ഉടമ
ലക്ഷ്യസ്ഥാന ഫയലുകളുടെ ഉടമസ്ഥാവകാശം മാറ്റുക. ഉടമയുടെ പേര് അല്ലെങ്കിൽ നൽകാം
സംഖ്യാപരമായി.

-r
--പരിഹരിക്കുക
--പരിഹരിക്കുക-പ്രതീകാത്മകം
--resolve-symbolic-link
--റിസോൾവ്-സിംലിങ്ക്
-S
--പ്രതീകാത്മകം
--സിംബോളിക്-ലിങ്ക്
--സിംലിങ്ക്
ചലിക്കുന്നതിന് പകരം പ്രതീകാത്മക ലിങ്കുകൾ സൃഷ്ടിക്കുന്നു. ഈ ഓപ്‌ഷനുകൾ &ln-ലേക്ക് കൈമാറുന്നു
അവിടെ വിവരിച്ചു.

-s
--സ്ട്രിപ്പ്
ലക്ഷ്യസ്ഥാന ഫയലുകളിൽ $PATH-ൽ ഉണ്ടായിരിക്കേണ്ട "സ്ട്രിപ്പ്" യൂട്ടിലിറ്റിയെ വിളിക്കുന്നു.

&ln [ഓപ്ഷൻ ...] ഉറവിട ഫയൽ destfile
&ln [ഓപ്ഷൻ ...] ഉറവിട ഫയൽ
&ln [ഓപ്ഷൻ ...] ഉറവിട ഫയൽ ... destdir
ബന്ധം ഉറവിട ഫയൽ ലേക്ക് destfile, ഒന്ന് ഉറവിട ഫയൽ നിലവിലെ ഡയറക്ടറി അല്ലെങ്കിൽ ഒന്നിലധികം
ഉറവിട ഫയൽs ടു destdir അതേ പേരിൽ.

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=ഫയലിന്റെ പേര്, -f, --force, -v,
--വാക്കുകൾ"

-r
--പരിഹരിക്കുക
--പരിഹരിക്കുക-പ്രതീകാത്മകം
--resolve-symbolic-link
--റിസോൾവ്-സിംലിങ്ക്
ഇതാണ് നിങ്ങൾ എപ്പോഴും "ln -s" ചെയ്യാൻ ആഗ്രഹിച്ചത്. കഠിനമായതിനേക്കാൾ പ്രതീകാത്മകമായി സൃഷ്ടിക്കുക
ലിങ്കുകൾ, വ്യക്തമാക്കിയ സ്ട്രിംഗുകളിലേക്കല്ല, യഥാർത്ഥത്തിൽ നൽകിയിരിക്കുന്ന ഫയലുകളിലേക്കാണ്.

-s
--പ്രതീകാത്മകം
--സിംബോളിക്-ലിങ്ക്
--സിംലിങ്ക്
ഹാർഡ് ലിങ്കുകളേക്കാൾ പ്രതീകാത്മകമായി സൃഷ്ടിക്കുക.

കുറിപ്പ്: വിവിധ ഫയലുകളിലോ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലോ, ഈ പ്രവർത്തനം പിന്തുണയ്ക്കുന്നില്ല. അല്ലെങ്കിൽ അത്
ആണ്, ഉദാ സിഗ്വിൻ, എന്നാൽ നിങ്ങൾ ഒരെണ്ണം ഉപയോഗിക്കുകയാണെങ്കിൽ നേറ്റീവ് വിൻഡോസ് കംപൈലറുകൾക്ക് മനസ്സിലാകില്ല.
ഒരു മേക്ക്ഫയലിനായി നിങ്ങൾക്ക് മാറ്റാൻ കഴിയില്ല, ഏതെങ്കിലും തരത്തിലുള്ള ഫലമെങ്കിലും ലഭിക്കുന്നതിന്, &ln, "&cp -l
-s"-ന് പകരം നിങ്ങൾക്കായി ഫയലുകൾ പകർത്താനാകും (ഡയറക്‌ടറികളല്ലെങ്കിലും). ഇത് നേടുന്നതിന്, നിങ്ങൾ
makepp-ലേക്ക് വിളിക്കുന്നതിന് മുമ്പ് ഇനിപ്പറയുന്ന വേരിയബിൾ കയറ്റുമതി ചെയ്യേണ്ടതുണ്ട്:

കയറ്റുമതി MAKEPP_LN_CP=1
&ln --resolve അല്ലെങ്കിൽ --symbolic ഒരു പ്രതീകാത്മകത സൃഷ്ടിക്കുന്നതിന് പകരം ഫയലുകൾ പകർത്തും
ലിങ്ക്.

കയറ്റുമതി MAKEPP_LN_CP=2
&ln ഒരു ഹാർഡ് ലിങ്ക് സൃഷ്ടിക്കുന്നതിനുപകരം ഫയലുകൾ പകർത്തും.

കയറ്റുമതി MAKEPP_LN_CP=3
&ln-ന്റെ എല്ലാ അഭ്യർത്ഥനകളും ഏതെങ്കിലും തരത്തിലുള്ളവ സൃഷ്‌ടിക്കുന്നതിന് പകരം ഫയലുകൾ പകർത്തും
ലിങ്ക്.

&mkdir [ഓപ്ഷൻ ...] ഡയറക്ടറി ...
ഡയറക്ടറികൾ സൃഷ്ടിക്കുക.

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=ഫയലിന്റെ പേര്, -f, --force, -v,
--വാക്കുകൾ"

-m മോഡ്
--മോഡ്=മോഡ്
സജ്ജമാക്കുന്നു മോഡ് ഉമാസ്‌ക് പരിഗണിക്കാതെ സൃഷ്‌ടിച്ച എല്ലാ ഡയറക്‌ടറികൾക്കും. മോഡ് ഒരു ആയിരിക്കണം
ഒക്ടൽ ചരട്.

-p
--മാതാവ്
ആവശ്യമായ പാരന്റ് ഡയറക്‌ടറികളും സൃഷ്‌ടിക്കുക. ഡയറക്‌ടറി സൃഷ്‌ടിക്കൽ പരാജയം അവഗണിക്കുക
ഇതിനകം നിലവിലുള്ള ഡയറക്ടറി കാരണം (ഇത് ഒരേസമയം സൃഷ്ടിച്ചതാണെങ്കിൽ പോലും
മറ്റൊരു പ്രക്രിയ).

&mv [ഓപ്ഷൻ ...] ഉറവിട ഫയൽ destfile
&mv [ഓപ്ഷൻ ...] ഉറവിട ഫയൽ
&mv [ഓപ്ഷൻ ...] ഉറവിട ഫയൽ ... destdir
നീക്കുക അല്ലെങ്കിൽ പേരുമാറ്റുക ഉറവിട ഫയൽ ലേക്ക് destfile, ഒന്ന് ഉറവിട ഫയൽ നിലവിലെ ഡയറക്ടറി അല്ലെങ്കിൽ ഒന്നിലധികം
ഉറവിട ഫയൽs ടു destdir അതേ പേരിൽ.

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=ഫയലിന്റെ പേര്, -f, --force, -v,
--വാക്കുകൾ"

&മുൻപ്രോസസ്സ് [ഓപ്ഷൻ ...] വേരിയബിൾ=നിർവചനം ... ഫയലിന്റെ പേര് ...
മേക്ക് ഫയലുകൾക്കായി makepp ചെയ്യുന്ന അതേ രീതിയിൽ തന്നെ ഇത് ഫയലുകളെ പ്രീപ്രോസസ് ചെയ്യുന്നു. ഇതാണ്
&ടെംപ്ലേറ്റിനേക്കാൾ ശക്തമാണ്, എന്നാൽ ധാരാളം ഫയലുകൾ ഉള്ള ഫയലുകൾക്ക് വാക്യഘടന അനുയോജ്യമല്ല
മേക്ക് ഫയലുകൾ അല്ലെങ്കിൽ സ്ക്രിപ്റ്റുകൾ പോലെയുള്ള "$" അടയാളങ്ങൾ.

സോപാധിക പ്രസ്താവനകളും അതുപോലെ "ഉൾപ്പെടുന്നു"/"_ഇൻക്ലൂഡ്" (ഇവിടെ
ഫയൽ നിർമ്മിക്കുകയോ മുകളിലേക്ക് തിരയുകയോ ചെയ്യരുത്), "perl"/"makeperl"/"perl_begin" അല്ലെങ്കിൽ
"sub"/"makesub", അല്ലെങ്കിൽ ഫയലിനുള്ളിൽ നിങ്ങൾ നിർവചിക്കുന്ന ഏതെങ്കിലും പ്രസ്താവനകൾ പ്രോസസ്സ് ചെയ്യുന്നു. ശൂന്യം
കമന്റ് ലൈനുകൾ ഒഴിവാക്കുകയും ചെയ്യുന്നു.

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

ഒരു സാധാരണ ലൈനിന് അത് പോലെ തന്നെ ഔട്ട്പുട്ട് ലഭിക്കുന്നു.
$(MAKEEXPRESSIONS) ഉള്ള ഒരു ലൈൻ വികസിപ്പിക്കുകയും ഔട്ട്പുട്ട് ചെയ്യുകയും ചെയ്യുന്നു.
ifdef WANTTHIS # നിർവചിച്ചാലും ഇല്ലെങ്കിലും ഔട്ട്പുട്ട് ലഭിക്കില്ല
ഔട്ട്പുട്ട് ലഭിച്ചേക്കില്ല
endif
ചില ഫയലുകൾ ഉൾപ്പെടുത്തുക
നിലവിലില്ലാത്ത ചില ഫയലുകൾ _include # അല്ലെങ്കിൽ -include
$()ശൂന്യമായ പദപ്രയോഗം ഉൾപ്പെടുത്തുന്നത് കീവേഡ് തിരിച്ചറിയുന്നതിൽ നിന്ന് തടയുന്നു.
# കമന്റ് ലൈനുകളും ശൂന്യമായ വരികളും വിഴുങ്ങുന്നു.

$()# അവർ ഒരു ശൂന്യമായ പദപ്രയോഗം കൊണ്ട് മുഖംമൂടിക്കപ്പെടുന്നില്ലെങ്കിൽ.
$()
ശൂന്യമായ പദപ്രയോഗം തടയുന്നു \$()
തിരിച്ചറിയപ്പെടുന്നതിൽ നിന്നുള്ള ബാക്ക്സ്ലാഷ് തുടർച്ച.

നൽകാം:

ഒരു സാധാരണ ലൈനിന് അത് പോലെ തന്നെ ഔട്ട്പുട്ട് ലഭിക്കുന്നു.
വികസിപ്പിക്കുകയും ഔട്ട്‌പുട്ട് ചെയ്യുകയും ചെയ്യുന്നതെന്തും ഉള്ള ഒരു ലൈൻ.
ഇവിടെയുള്ള ഉള്ളടക്കത്തിൽ ഒട്ടനവധി മന്ദബുദ്ധികൾ...
ശൂന്യമായ പദപ്രയോഗം ഉൾപ്പെടുത്തുന്നത് കീവേഡ് തിരിച്ചറിയുന്നതിൽ നിന്ന് തടയുന്നു.
# അവർ ഒരു ശൂന്യമായ ഭാവം കൊണ്ട് മുഖംമൂടി ചെയ്യാത്തപക്ഷം.

ശൂന്യമായ പദപ്രയോഗം തടയുന്നു \
തിരിച്ചറിയപ്പെടുന്നതിൽ നിന്നുള്ള ബാക്ക്സ്ലാഷ് തുടർച്ച.

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=ഫയലിന്റെ പേര്, -f, --force, -o,
--output=ഫയലിന്റെ പേര്, -O, --outfail, -S, --synclines, -v, --verbose"

-a
--അസൈൻമെന്റ്
ഫയലുകൾക്കുള്ളിലെ അസൈൻമെന്റുകളും makepp പോലെ പരിഗണിക്കുക. അയ്യോ, അത്തരം വരികൾ പാടില്ല
ശൂന്യമായ "$()" ഉപയോഗിച്ച് മുഖംമൂടി, കാരണം വേരിയബിൾ നാമങ്ങൾ നിർമ്മിക്കുന്നത് നിയമപരമാണ്
ഭാവങ്ങൾ. ഇത് കൂടാതെ "നിർവചിക്കുക" എന്ന പ്രസ്താവനകൾ തിരിച്ചറിയുന്നു,
"കയറ്റുമതി"/"അൺഎക്സ്പോർട്ട്", "ഓവർറൈഡ്" (ഇവ "$()" ഉപയോഗിച്ച് മറയ്ക്കാം).

-h \\%ഹാഷ്
--hashref=\\%ഹാഷ്
ഇത് ദൈർഘ്യമേറിയ മൂല്യങ്ങൾ ഉൾപ്പെടെയുള്ള വേരിയബിൾ മൂല്യങ്ങളുടെ പ്രീഅലോക്കേഷൻ അനുവദിക്കുന്നു
ഒരു കമാൻഡിൽ പാസ്സാക്കി. പാസാക്കിയ എക്‌സ്‌പ്രഷൻ a നൽകുന്ന ഏതെങ്കിലും പേൾ കോഡായിരിക്കാം
ഹാഷ് റഫറൻസ്. ഇത് കമാൻഡിലേക്ക് കൈമാറിയ മറ്റേതെങ്കിലും വേരിയബിളുകളുമായി ലയിപ്പിച്ചിരിക്കുന്നു,
മറ്റൊരു "--hashref" ഓപ്ഷനിൽ നിന്ന് ഉൾപ്പെടെ.

&rm [ഓപ്ഷൻ ...] ഫയലിന്റെ പേര് ...
നിങ്ങൾക്ക് ഡയറക്‌ടറി റൈറ്റ് അനുമതിയുണ്ടെങ്കിൽ ഫയലുകൾ ഇല്ലാതാക്കുക. ഇതാണ് Unix "rm -f" ചെയ്യുന്നത്
ഇല്ലാതാക്കുക, കാരണം ഇതിന് സംവേദനാത്മക ഉപയോഗത്തിന് ഒരു പ്രത്യേക പരിരക്ഷയുണ്ട്
മേക്ക് ഫയൽ.

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=filename, -v, --verbose"

-f
--ശക്തിയാണ്
ഇത് നിലവിലില്ലാത്ത ഫയലുകളെക്കുറിച്ചുള്ള പരാതികളെ തടയുന്നു. അതൊരു പാർശ്വഫലമാണ്
Unix-ൽ ഓപ്ഷൻ ഉണ്ട്, ഇവിടെ അർത്ഥമുള്ളത് മാത്രം.

-m
--metainfo
നൽകിയിരിക്കുന്ന ഫയലുകൾക്ക് പുറമേ, മെറ്റാ ഇൻഫർമേഷൻ മേക്കപ്പും ഇത് ഇല്ലാതാക്കുന്നു
അവരെ കുറിച്ച് .makepp ഡയറക്ടറിയിൽ സംഭരിക്കുന്നു. അങ്ങനെ മേക്കപ്പ് തനിക്കറിയാവുന്നതെല്ലാം മറക്കുന്നു
നൽകിയിരിക്കുന്ന ഫയലുകളെക്കുറിച്ച്. ഇതിനുശേഷം .makepp ഡയറക്ടറി ശൂന്യമായാൽ, അതും
ഇല്ലാതാക്കിയിരിക്കുന്നു.

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

$(ഫോണി ക്ലീനോൾഡ്):
&rm -fm $(പഴഞ്ഞത് മാത്രം **/*)

$(ഫോണി ക്ലീൻ): ക്ലീൻഓൾഡ്
&rm -f $(വൈൽഡ്കാർഡ് **/*.[ao])

$(phony distclean): വൃത്തിയാക്കുക
&rm -fm $(ലക്ഷ്യങ്ങൾ മാത്രം **/*)

& അടുക്കുക [ഓപ്ഷൻ ...] ഫയലിന്റെ പേര് ...
എല്ലാ ഫയലുകളും നിഘണ്ടു ക്രമത്തിൽ അടുക്കുന്നു. ഇത് വലിയ കാര്യങ്ങളിൽ കാര്യക്ഷമമല്ല
ഫയലുകൾ, കാരണം ഇത് പൂർണ്ണമായും മെമ്മറിയിൽ സംഭവിക്കുന്നു. യുടെ സംയോജിത വലുപ്പമാണെങ്കിൽ അത് പരാജയപ്പെടും
എല്ലാ ഫയലുകളും നിങ്ങൾക്ക് അർഹമായ മെമ്മറി കവിയുന്നു.

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=ഫയലിന്റെ പേര്, -f, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=filename, -O, --outfail,
--record-size=number, -s, --separator=string, -v, --verbose"

-c പെർൽകോഡ്
--താരതമ്യം=പെർൽകോഡ്
പെർൽകോഡ് ഒരു പേൾ സോർട്ട് ബ്ലോക്കിനെ പ്രതിനിധീകരിക്കുന്നു, രണ്ട് കാൻഡിഡേറ്റുകൾ $a എന്നതിലും
$b.

-n
--സംഖ്യാപരമായ
--സംഖ്യാക്രമം
ഇത് റെക്കോർഡുകളുടെ തുടക്കത്തിൽ സംഖ്യാപരമായി അടുക്കുന്നു. മുൻനിര വൈറ്റ്‌സ്‌പേസ് ആണ്
ഒഴിവാക്കി. അക്കങ്ങൾ ഇല്ലെങ്കിൽ നിങ്ങൾക്ക് "--transform", "--detransform" എന്നിവ ഉപയോഗിക്കാം
ആരംഭം.

-r
--വിപരീതം
വിപരീത ക്രമത്തിൽ ഫലങ്ങൾ ഔട്ട്പുട്ട് ചെയ്യുക. ഇത് സ്റ്റാൻഡേർഡ് ഓപ്ഷൻ മറയ്ക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക
"-r" അത് "--record-size" ആയി നൽകണം.

-t പെർൽകോഡ്
--transform=പെർൽകോഡ്
-d പെർൽകോഡ്
--detransform=പെർൽകോഡ്
നിങ്ങൾക്ക് സങ്കീർണ്ണമായ ഒരു കോഡ് ഉണ്ടെങ്കിൽ, സോർട്ടിംഗ് ആനുപാതികമായി കൂടുതൽ കൂടുതൽ ചെലവേറിയതായിരിക്കും
റെക്കോർഡുകളുടെ എണ്ണം n, കാരണം കോഡിനെ O(n ലോഗ്(n)) തവണ. ഒഴിവാക്കാൻ
അതായത്, ആദ്യം പരിഷ്ക്കരിച്ചുകൊണ്ട്, അടുക്കുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ നിങ്ങൾക്ക് Perl-നെ അനുവദിക്കാം
സ്ട്രിംഗുകൾ, സങ്കീർണ്ണമായ തിരയൽ മാനദണ്ഡം വേർതിരിച്ചെടുക്കൽ ഒരു റെക്കോർഡിന് ഒരിക്കൽ സംഭവിക്കുന്നു,
അവ അടുക്കിക്കഴിഞ്ഞാൽ അവ വീണ്ടും പരിഷ്കരിക്കുന്നു.

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

എക്‌സ്‌ട്രാക്‌റ്റുചെയ്‌ത സോർട്ട് മാനദണ്ഡങ്ങളുടെ ഘടനയിലേക്ക് സ്ട്രിംഗുകളെ മാറ്റുന്നു, അത് നിങ്ങളുടേതാണ്
"- താരതമ്യം ചെയ്യുക" പെർൽകോഡ് ക്യാൻ പിക്ക് അപ്പ് ഷ്വാർട്‌സിയൻ ട്രാൻസ്‌ഫോം (എസ്‌ടി) എന്നറിയപ്പെടുന്നു.
എല്ലാം സ്ട്രിംഗിൽ തന്നെ പായ്ക്ക് ചെയ്യുന്നു, അങ്ങനെ "--താരതമ്യപ്പെടുത്തരുത്" പെർൽകോഡ് is
വിലയേറിയ പേൾ നടത്താതെ മുഴുവൻ സോർട്ടിംഗും അനുവദിക്കുന്നത് ആവശ്യമാണ്
കോഡ്, ഗുട്ട്മാൻ-റോസ്ലർ ട്രാൻസ്ഫോം (GRT) എന്നറിയപ്പെടുന്നു. വഴി നിങ്ങൾക്ക് നുറുങ്ങുകൾ കണ്ടെത്താം
വെബിൽ ആ പേരുകൾക്കായി തിരയുന്നു.

# മൂല്യമനുസരിച്ച് സംഖ്യാ പദപ്രയോഗങ്ങൾ വിലയേറിയ രീതിയിൽ അടുക്കുക ($$ മേക്കപ്പ് വിപുലീകരണത്തിൽ നിന്ന് $ പരിരക്ഷിക്കുന്നു)
&sort --compare 'eval( $$a ) <=> eval( $$b )' $(input) -o >>$(output)

# കേസ് സെൻസിറ്റീവ് സോർട്ടിംഗിനുള്ള എസ്.ടി
&sort -t '[lc, $$_]' -c '$$a->[0] cmp $$b->[0]' -d '$$_->[1]' $(ഇൻപുട്ട്) - o >>$(ഔട്ട്പുട്ട്)

Makeppfile-ൽ മറ്റെവിടെയെങ്കിലും നിർവചിച്ചിരിക്കുന്ന പരിഷ്ക്കരണ പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കുന്ന # GRT
&sort -t &transform -d &detransform $(ഇൻപുട്ട്) -o >>$(ഔട്ട്പുട്ട്)

-u
--uniq
--അതുല്യമായ
അടുക്കിയ ശേഷം, തനിപ്പകർപ്പുകൾ ഇല്ലാതാക്കുക. ഇവ ഒന്നുകിൽ ഒരേ വരികളാണ്, അല്ലെങ്കിൽ എങ്കിൽ
"--compare" ഓപ്‌ഷൻ നൽകിയിരിക്കുന്നു, അത് ഏതാണ് പെർൽകോഡ് തത്തുല്യമായ റിപ്പോർട്ടുകൾ.

&ടെംപ്ലേറ്റ് [ഓപ്ഷൻ ...] മാക്രോ=നിർവചനം ... ഫയലിന്റെ പേര് ...
ഇതൊരു മാക്രോ പ്രീപ്രൊസസ്സറാണ്, സി പ്രീപ്രോസസർ അല്ലെങ്കിൽ "m4" പോലെ അത്ര ശക്തമല്ല.
കൂടുതൽ ശക്തമായ ഒരു ബദലിനായി &പ്രീപ്രോസസ് കാണുക. ഇത് ഓട്ടോമേക്കിന്റെ മാക്രോയിൽ നിന്ന് പ്രചോദനം ഉൾക്കൊണ്ടതാണ്
പകരം വയ്ക്കൽ Makefile.am ഒപ്പം Makefile.in. പക്ഷേ അത് അതിനപ്പുറമാണ്. ഏതെങ്കിലും സാധാരണ വാചകം
മാറ്റമില്ലാതെ കടന്നുപോകുന്നു. പ്രത്യേക നിർമ്മിതികൾ സ്ഥിരസ്ഥിതിയായി "@" ഉപയോഗിച്ച് വേർതിരിച്ചിരിക്കുന്നു. അവർ
നിങ്ങൾ "-r, --record-size" അല്ലെങ്കിൽ "--separator" എന്നിവയിൽ ഒന്ന് കടന്നില്ലെങ്കിൽ ഒരു വരിയിൽ ഒതുങ്ങണം.

@# അഭിപ്രായം @
സ്ക്രിപ്റ്റ് "#" ലൈൻ എൻഡ് കമന്റ് സിന്റാക്സിൽ നിന്ന് കടമെടുത്തിട്ടുണ്ടെങ്കിലും, ഇതാണ്
ഒരു ഇൻലൈൻ അഭിപ്രായം.

@മാക്രോ@
ഈ നിർമ്മിതിയെ മൂല്യം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു മാക്രോ. മാക്രോ പേരുകൾ തുടങ്ങണം
ഒരു അക്ഷരം അല്ലെങ്കിൽ അണ്ടർസ്കോർ, അതിനുശേഷം എത്രയോ അക്ഷരങ്ങൾ, അടിവരകൾ, മൈനസുകൾ അല്ലെങ്കിൽ
ഡോട്ടുകൾ. മേക്കപ്പ് പേരുകളിൽ നിന്ന് വ്യത്യസ്തമായി, അടിവരയും മൈനസും തുല്യമല്ല.

@മാക്രോ(arg1,arg2...)@
ആദ്യത്തേത് പോലെ, പക്ഷേ പരാമീറ്റർ. ആർഗുകൾ $1 മുതൽ $9 വരെ മാറ്റിസ്ഥാപിക്കുന്നു അല്ലെങ്കിൽ
"${നമ്പർ}" മൂല്യത്തിൽ. അല്ലെങ്കിൽ, മൂല്യം ഒരു പേൾ ഫംഗ്‌ഷൻ ആണെങ്കിൽ, അവ ഇതായി കൈമാറും
സാധാരണ പരാമീറ്ററുകൾ. ഫലം മുഴുവൻ നിർമ്മാണത്തെയും മാറ്റിസ്ഥാപിക്കുന്നു. ഒരു ലെവൽ
മാക്രോ നെസ്റ്റിംഗ് സാധ്യമാണ്, കാരണം പരാൻതീസിസിലെ ആർഗുകളിൽ പ്ലെയിൻ അടങ്ങിയിരിക്കാം
"@f(@x@)@" എന്നതിലെ പോലെ "@MACRO@" അഭ്യർത്ഥനകൾ, ഇവിടെ "@x@" വിപുലീകരിക്കപ്പെടുന്നതിന് മുമ്പ്
"f" ന്റെ ശരീരത്തിലേക്ക് മാറ്റി.

@ഉൾപ്പെടുന്നു(ഫയലിന്റെ പേര്)@
ഇത് മാത്രമാണ് മുൻകൂട്ടി നിശ്ചയിച്ചിട്ടുള്ള മാക്രോ. അത് &ടെംപ്ലേറ്റ്-പ്രോസസ്സ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു
പേരുള്ള ഫയലിന്റെ ഉള്ളടക്കം. എല്ലാ മാക്രോകളെയും പോലെ ഇത് a യുടെ മധ്യത്തിൽ സംഭവിക്കാം
ലൈൻ. അയ്യോ, അത് കാരണം, "-S, --synclines" ഫയൽ ഉൾപ്പെടുത്തൽ അവഗണിക്കുന്നു
എല്ലാം ഫയലിൽ നിന്ന് വരുന്നതായി തോന്നുന്നു.

@മാക്രോ=നിര്വചനം@
@മാക്രോ?=നിര്വചനം@
ഇത് ഫയലിനുള്ളിലെ മാക്രോയെ നിർവ്വചിക്കുന്നു. ഇത് ഒന്നുമില്ലാതെ മാറ്റിസ്ഥാപിക്കുന്നു. രണ്ടാമത്തെ
മാക്രോ നിർവചിച്ചിട്ടില്ലെങ്കിൽ മാത്രമേ ഫോം പ്രാബല്യത്തിൽ വരികയുള്ളൂ, ഒരുപക്ഷേ കമാൻഡിൽ
ലൈൻ.

@മാക്രോ { പെർൽകോഡ് }@
ഇത് ഒരു മാക്രോയെ നിർവചിക്കുന്നു, അതിന്റെ ബോഡി ഒരു പേൾ സബ് ആണ്. വാദങ്ങൾ, എങ്കിൽ
എന്തെങ്കിലും ഉണ്ട്, @_ ആയി കടന്നുപോകുക.

@{ പെർൽകോഡ് }@
ഇത് പ്രവർത്തിപ്പിക്കുന്നു പെർൽകോഡ് ഉടനടി റിട്ടേൺ മൂല്യം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു.

സവിശേഷമായ കാര്യങ്ങൾ ഉൾച്ചേർക്കുന്നതിനുള്ള ഒരു വാക്യഘടന മാത്രമേ നമ്മൾ ഇതുവരെ കണ്ടിട്ടുള്ളൂ. മറ്റൊന്നുണ്ട്
മൾട്ടിലൈൻ വാക്യഘടന, കൂടാതെ രണ്ടും ഒരു ന്യൂലൈൻ അടിച്ചമർത്താൻ ഒരു വ്യതിയാനത്തെ അനുവദിക്കുന്നു. ഇവയാണ്
അന്തർനിർമ്മിത വാക്യഘടനകൾ (ചുവടെയുള്ള ഓപ്‌ഷനുകൾ ഉപയോഗിച്ച് കോൺഫിഗർ ചെയ്യാവുന്നതാണ്). ഇവിടെ പ്രത്യേക നിലകൊള്ളുന്നു
മുകളിൽ കാണിച്ചിരിക്കുന്ന ഏതെങ്കിലും നിർമ്മാണങ്ങൾ:

@പ്രത്യേക@
@പ്രത്യേക@\
ഇത് ഒരു വരിയിൽ എവിടെയും ഗുണിച്ചാൽ ദൃശ്യമാകും. വേരിയന്റ് ഉടൻ പിന്തുടരുന്നു
"\" വരിയുടെ അവസാനത്തിൽ മാത്രമേ പ്രവർത്തിക്കൂ. ഇത് ഇനിപ്പറയുന്ന ലൈൻ ബ്രേക്ക് മാറ്റിസ്ഥാപിക്കുന്നു.

@@പ്രത്യേക@@ സാധാരണമായ ടെക്സ്റ്റ് @@
@@പ്രത്യേക@@ സാധാരണമായ ടെക്സ്റ്റ് @@\
ഇത് മുമ്പത്തേത് പോലെയാണ്. എന്നിരുന്നാലും സാധാരണ വാചകം, അത് മാറ്റിസ്ഥാപിക്കപ്പെടുന്നു,
ഒന്നിലധികം വരികൾ പരത്താൻ കഴിയും. നിങ്ങൾക്ക് ചുറ്റുമുള്ള കമന്റ് ലൈനുകളിൽ പ്രത്യേക ഭാഗങ്ങൾ ഇടാം
ഒരു അൺഇൻസ്റ്റാൾ ചെയ്ത സ്ക്രിപ്റ്റിൽ മാത്രം ആവശ്യമുള്ള സോഴ്സ് കോഡ്, ഇല്ലാതാക്കാൻ അല്ലെങ്കിൽ
ഇൻസ്റ്റാളേഷൻ പ്രക്രിയയിൽ മാറ്റിസ്ഥാപിച്ചു:

# @@# അടുത്ത 2 വരികൾ അപ്രത്യക്ഷമാകും @@
echo നിങ്ങൾ ഈ സ്ക്രിപ്റ്റിന്റെ അൺഇൻസ്റ്റാൾ ചെയ്ത പതിപ്പാണ് പ്രവർത്തിപ്പിക്കുന്നത്
#@@
# @@REPLAMCENT@@
echo മറ്റെന്തെങ്കിലും ഇവിടെ ഉണ്ടാകും
#@@

വിവിധ സാധ്യതകൾ കാണിക്കുന്ന അർത്ഥശൂന്യമായ ഉദാഹരണം:

@m1=ചില നിർവചനം@\
@m2=foo $1 ബാർ@\
@middle_of_arg=iddl@\
@m1@ @m2(m@middle_of_arg@e)@
@@m2(നിരവധി വരികൾ)@@
...
@@ പ്ലെയിൻ ടെക്സ്റ്റ് 1 + 2 = @{ 1 + 2 }@

മാറുന്നു

ചില നിർവചനം foo മിഡിൽ ബാർ
നിരവധി വരികൾ ബാർ പ്ലെയിൻ ടെക്സ്റ്റ് 1 + 2 = 3

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=ഫയലിന്റെ പേര്, -f, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=filename, -O, --outfail, -r,
--record-size=number, --separator=string, -S, --synclines, -v, --verbose"

-d
--നിർവചിച്ചിരിക്കുന്നത്
യഥാർത്ഥത്തിൽ നിർവചിച്ചിരിക്കുന്ന മാക്രോകളുടെ സന്ദർഭങ്ങൾ മാത്രം മാറ്റിസ്ഥാപിക്കുക. ഈ ഓപ്ഷൻ ഇല്ലാതെ
നിർവചിക്കപ്പെടാത്തവയെല്ലാം ഒന്നുമില്ലാതെ മാറ്റപ്പെടും.

-h \\%ഹാഷ്
--hashref=\\%ഹാഷ്
ഇത് ദൈർഘ്യമേറിയവ ഉൾപ്പെടെയുള്ള മാക്രോ മൂല്യങ്ങൾ മുൻകൂട്ടി അനുവദിക്കാൻ അനുവദിക്കുന്നു
ഒരു കമാൻഡിൽ പാസ്സാക്കി. പാസാക്കിയ എക്‌സ്‌പ്രഷൻ a നൽകുന്ന ഏതെങ്കിലും പേൾ കോഡായിരിക്കാം
ഹാഷ് റഫറൻസ്. കമാൻഡിലേക്ക് കൈമാറിയ മറ്റേതെങ്കിലും മാക്രോകളുമായി ഇത് ലയിപ്പിച്ചിരിക്കുന്നു,
മറ്റൊരു "--hashref" ഓപ്ഷനിൽ നിന്ന് ഉൾപ്പെടെ. ഒരു ഹാഷ് മൂല്യവും ഒരു കോഡായിരിക്കാം
റഫറൻസ്, അങ്ങനെയെങ്കിൽ, "@macro { എന്ന പോലെ ഫംഗ്‌ഷൻ വിളിക്കപ്പെടും. പെർൽകോഡ് }@"
നിർവചനങ്ങൾ.

-s /പ്രിഫിക്സ്/സഫിക്സ്/
--ലളിതം=/പ്രിഫിക്സ്/സഫിക്സ്/
ഉപയോഗം പ്രിഫിക്‌സ് ഒപ്പം സഫിക്സ് മുമ്പും ശേഷവും പ്രത്യേക യഥാക്രമം "@" എന്നതിന് പകരം. ദി
ആദ്യ പ്രതീകം സെപ്പറേറ്ററാണ്, അത് ഒരു സ്ലാഷ് ആകേണ്ടതില്ല. ഈ മൂല്യങ്ങൾ Perl ആണ്
regexps. "(...)" പോലെയുള്ള ഗ്രൂപ്പിംഗ് നിങ്ങൾ പരിചയപ്പെടുത്തരുത്, എന്നാൽ "(?:...)" ശരിയാണ്.

-m /പ്രിഫിക്സ്/സഫിക്സ്/ആഫ്റ്റർപ്രിഫിക്സ്/[ആഫ്റ്റർസഫിക്സ്/]
--multiline=/പ്രിഫിക്സ്/സഫിക്സ്/ആഫ്റ്റർപ്രിഫിക്സ്/[ആഫ്റ്റർസഫിക്സ്/]
ഉപയോഗം പ്രിഫിക്‌സ്, സഫിക്സ് ഒപ്പം ആഫ്റ്റർപ്രിഫിക്സ് മുമ്പും ശേഷവും പ്രത്യേക ഒപ്പം അവസാനം
"@@" എന്നതിന് പകരം യഥാക്രമം തടയുക. എങ്കിൽ അനന്തരപ്രത്യയം മാക്രോ നാമവും നൽകിയിരിക്കുന്നു
അതിനുമുമ്പ് ആവർത്തിക്കണം. ആദ്യത്തെ പ്രതീകം സെപ്പറേറ്ററാണ്, അത് ആവശ്യമില്ല
ഒരു സ്ലാഷ്. ഉദാ ഒരു XML-ish, അതിൽ നിങ്ങൾ "--defined" എന്ന് ചേർക്കണം
നിങ്ങൾ നിർവചിച്ചിട്ടില്ലാത്ത മറ്റ് ടാഗുകൾ സംരക്ഷിക്കുക:

--defined --simple=|<|/>| --multiline=|<|>| |

അല്ലെങ്കിൽ, മികച്ചത്, പ്രോസസ്സിംഗ് നിർദ്ദേശങ്ങൾ ഉപയോഗിക്കുക " ", അത്തരമൊരു ഉദ്ദേശ്യത്തിനായി ഉദ്ദേശിച്ചത്:

--defined --simple='|<\?|\?>|'

അല്ലെങ്കിൽ, നിങ്ങൾക്ക് ഇത് "&entity;" എന്നതുമായി സംയോജിപ്പിക്കണമെങ്കിൽ ലളിതമായ മാക്രോയ്ക്കുള്ള വാക്യഘടന
മാറ്റിസ്ഥാപിക്കലുകൾ (അഭിപ്രായങ്ങളല്ലാത്ത "☺" എന്ന സംഖ്യാ ഘടകങ്ങളെ സംരക്ഷിക്കുന്നു):

--defined --simple='_(?:&(?!#)|<\?)_(?:;|\?>)_'

&സ്പർശിക്കുക [ഓപ്ഷൻ ...] ഫയലിന്റെ പേര് ...
ഓരോ ഫയലിന്റെയും പരിഷ്ക്കരണവും ആക്സസ് ടൈംസ്റ്റാമ്പുകളും ഇപ്പോൾ അപ്ഡേറ്റ് ചെയ്യുന്നു. ഫയൽ ആണെങ്കിൽ
നിലവിലില്ല, അത് സൃഷ്ടിക്കപ്പെടുന്നു.

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=filename, -v, --verbose"

&അൺഇൻസ്റ്റാൾ ചെയ്യുക [ഓപ്ഷൻ ...] [ഫയലിന്റെ പേര് ...]
&ഇൻസ്റ്റാൾ ചെയ്ത് മുമ്പ് ഇൻസ്റ്റാൾ ചെയ്ത ഫയലുകൾ അൺഇൻസ്റ്റാൾ ചെയ്യുക. ദി ഫയലിന്റെ പേര്എഴുതിയ ലോഗ് ഫയലുകളാണ്
&ഇൻസ്റ്റാൾ ചെയ്യുക. ഒന്നും നൽകിയിട്ടില്ലെങ്കിൽ, അല്ലെങ്കിൽ ഒരു "--inpipe" ഓപ്ഷൻ, സ്ഥിരസ്ഥിതി ലോഗ്ഫയൽ വായിക്കുന്നു
&ഇൻസ്റ്റാൾ ചെയ്യുക.

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=filename, -i,
--inpipe=shellcommand, -I, --infail, -v, --verbose"

&uniq [ഓപ്ഷൻ ...] ഫയലിന്റെ പേര് ...
തുടർച്ചയായ തുല്യ വരികളിൽ ഒന്നൊഴികെ മറ്റെല്ലാം നിരസിക്കുക.

"സ്റ്റാൻഡേർഡ് ഓപ്ഷനുകൾ": "-A, --args-file, --arguments-file=ഫയലിന്റെ പേര്, -f, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=filename, -O, --outfail, -r,
--record-size=number, -s, --separator=string, -S, --synclines, -v, --verbose"

-c പെർൽകോഡ്
--താരതമ്യം=പെർൽകോഡ്
ഈ പെർൽകോഡ് $a, $b എന്നിവയിൽ മുമ്പത്തേതും നിലവിലുള്ളതുമായ വരികൾ ലഭിക്കുകയും തിരികെ നൽകുകയും ചെയ്യും
രണ്ട് വരികൾ തുല്യമായി കണക്കാക്കുകയാണെങ്കിൽ ശരിയാണ്.

&uniq --compare='lc( $$a ) eq lc $$b' $(ഇൻപുട്ടുകൾ) -o $(ഔട്ട്‌പുട്ട്)

അനുകരിക്കാവുന്നത് കമാൻഡുകൾ
വിവിധ കാര്യങ്ങൾ അന്തർനിർമ്മിതമല്ല, എന്നാൽ മറ്റ് കമാൻഡുകൾ ഉപയോഗിച്ച് നേടാനാകും:

awk &sed ഉപയോഗിക്കുക.

chgrp
ചൗൺ
ഈ കമാൻഡുകൾ മിക്കവാറും പോർട്ടബിൾ അല്ല! അവർ ഒന്നുകിൽ നിശബ്ദമായി ഒന്നും ചെയ്യില്ല അല്ലെങ്കിൽ പരാജയപ്പെടും,
സിസ്റ്റത്തെ ആശ്രയിച്ച്. സാധാരണയായി റൂട്ട് മാത്രമേ ഈ പ്രവർത്തനങ്ങൾ നടത്താൻ കഴിയൂ, അതായത്
എന്തുകൊണ്ട് &ഇൻസ്റ്റാൾ കമാൻഡ് വഴി മാത്രമേ അവ ലഭ്യമാകൂ.

cpp &പ്രീപ്രോസസ് അല്ലെങ്കിൽ &ടെംപ്ലേറ്റ് ഉപയോഗിക്കുക.

തീയതി
ഇവയിലേതെങ്കിലും ഭാഗികമായി ഒരേ കാര്യം ചെയ്യുന്നു:

&എക്സ്പ്രർ പ്രാദേശിക സമയം
&expr gmtime

തെറ്റായ
ആർഗ്യുമെന്റോ 0യോ ഇല്ലാതെ &എക്സ്പ്രർ ഉപയോഗിക്കുക.

തല
വാൽ
&grep അല്ലെങ്കിൽ "&cut --lines" ഉപയോഗിച്ച് നിങ്ങൾക്ക് സമാന ഫലം നേടാനാകും:

&grep 1..10 ഫയൽ # ആദ്യ പത്ത് വരികൾ
&grep 10..eof file # പത്താം മുതലുള്ള എല്ലാ വരികളും
&കട്ട് --ലൈനുകൾ -10..-1 ഫയൽ # അവസാനത്തെ പത്ത് വരികൾ

&grep എന്നതിൽ 1..10 എന്നത് പേളിന്റെ ലൈൻ നമ്പർ ഫ്ലിപ്പ്-ഫ്ലോപ്പ് ഓപ്പറേറ്ററാണ്, ഇത് അരോചകമാണ്
1-ൽ ആരംഭിക്കുന്നു. 0-ൽ ആരംഭിക്കരുത്, അല്ലെങ്കിൽ ഫ്ലിപ്പ്-ഫ്ലോപ്പ് ഒരിക്കലും സത്യമാകില്ല.

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

ഉപ csv2txt {
ഫോംലൈൻ "\@<<<<<<<<<<<<<< ^###########.##\n", വിഭജിക്കുക ',';
$_ = $^A;
$^A = '';
}

%.txt: %.csv
&sed &csv2txt $(ഇൻപുട്ട്) -o $(ഔട്ട്പുട്ട്)

m4 &പ്രീപ്രോസസ് അല്ലെങ്കിൽ &ടെംപ്ലേറ്റ് ഉപയോഗിക്കുക.

rm ആണ്
&rm ഉപയോഗിക്കുക.

tr ഉപയോഗിക്കുക &സെഡ്.

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