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

പട്ടിക:

NAME

mmake - ഒരു Java Makefile സൃഷ്ടിക്കുക

സിനോപ്സിസ്

mmake [ -d ⎪ -v ]

വിവരണം

ഈ പ്രോഗ്രാം ജാവ സോഴ്സ് ഫയലുകൾക്കായി ഒരു മേക്ക്ഫയൽ സൃഷ്ടിക്കും. ഉപയോഗിക്കുക -d സ്വീകരിക്കാനുള്ള ഓപ്ഷൻ
എല്ലാ സ്ഥിരസ്ഥിതികളും.

mmake പ്രവർത്തിപ്പിച്ചതിന് ശേഷം, നിങ്ങൾ ആരംഭിച്ച ഡയറക്ടറിയിൽ നിങ്ങൾക്ക് ഒരു Makefile ലഭിക്കും
പരിപാടി. നിലവിലെ ഡയറക്‌ടറിയിലും ഏത് ഡയറക്‌ടറിയിലും ജാവ ഫയലുകൾ Makefile കൈകാര്യം ചെയ്യും
ഉപ ഡയറക്ടറികൾ.

mmake ഉപയോഗിച്ച് ജനറേറ്റുചെയ്‌ത Makefile ഇനിപ്പറയുന്ന രീതിയിൽ ഉപയോഗിക്കുക:

ജാവ ഫയലുകൾ കംപൈൽ ചെയ്യാൻ ടൈപ്പ് ചെയ്യുക ഉണ്ടാക്കുക. ഇതിലൊന്ന് ഉപയോഗിച്ച് മേക്ക് പ്രവർത്തിപ്പിക്കാനും സാധിക്കും
ഇനിപ്പറയുന്ന ലക്ഷ്യങ്ങൾ: പ്രമാണം, വൃത്തിയായി, സഹായം, ഭരണി, srcjar, ബണ്ടിൽ, ഇൻസ്റ്റാൾ ചെയ്യുക, അൺഇൻസ്റ്റാൾ ചെയ്യുക, ടാഗുകൾ ഒപ്പം
ആശ്രയിക്കുന്നു സോഴ്‌സ് ഫയലുകളിൽ 'make doc' javadoc പ്രവർത്തിപ്പിക്കുന്നിടത്ത്, ഒരു ഫയലിൽ മാത്രമേ ഇത് പ്രവർത്തിക്കൂ.
പാക്കേജ്. 'make clean' എന്ന കമാൻഡ് ക്ലാസ് ഫയലുകളും മറ്റ് താൽക്കാലിക ഫയലുകളും നീക്കം ചെയ്യുന്നു. ദി
'make jar' എന്ന കമാൻഡ് എല്ലാ ക്ലാസ് ഫയലുകളും (നിങ്ങളുടെ മറ്റ് ഫയലുകളും) ഒരു ജാർ ഫയൽ സൃഷ്ടിക്കുന്നു
ചോയ്സ്, Makefile-ലെ JAR_OBJS വേരിയബിൾ കാണുക). 'make srcjar' എന്ന കമാൻഡ് സൃഷ്ടിക്കുന്നു a
എല്ലാ ജാവ ഫയലുകളുമുള്ള jar ഫയൽ. 'mac bundle' എന്ന കമാൻഡ് ഒരു Mac OS X ആപ്ലിക്കേഷൻ സൃഷ്ടിക്കുന്നു
എല്ലാ ജാർ ഫയലും ബണ്ടിൽ ചെയ്യുക. 'make install' എന്ന കമാൻഡ് ഒരു jar ഫയൽ, ആപ്പ് ഇൻസ്റ്റാൾ ചെയ്യും
ബണ്ടിൽ, ക്ലാസ് ഫയലുകൾ, നിങ്ങൾ നിർമ്മിച്ച ഏതെങ്കിലും ഷെൽ റാപ്പറുകൾ. (ഒരു ഷെൽ സ്ക്രിപ്റ്റിൽ ഉണ്ടായിരിക്കണം
വിപുലീകരണം .sh ഇൻസ്റ്റാൾ ചെയ്യണം). ഇൻസ്റ്റാൾ ചെയ്ത ഫയലുകൾ നീക്കം ചെയ്യാൻ 'make uninstall' ഉപയോഗിക്കുക. ദി
'സഹായം ഉണ്ടാക്കുക' എന്ന കമാൻഡ്, ലഭ്യമായ ലക്ഷ്യങ്ങളുള്ള ഒരു സഹായ വാചകം കാണിക്കുന്നു. 'ടാഗുകൾ ഉണ്ടാക്കുക' എന്ന കമാൻഡ്
Emacs-നായി ഒരു ടാഗ് ഫയൽ സൃഷ്ടിക്കും. അവസാനം 'ആശ്രിതമാക്കുക' എന്ന കമാൻഡ് സൃഷ്ടിക്കുന്നു a
ക്ലാസ് ഫയലുകൾക്കായുള്ള ഡിപൻഡൻസി ഗ്രാഫ്. (ഡിപൻഡൻസി ഗ്രാഫ് എന്ന പേരിൽ ഒരു ഫയലിൽ ഇടും
makefile.dep, ഇത് മേക്ക് ഫയലിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്)

ഓരോ തവണയും നിങ്ങളുടെ പ്രോജക്റ്റിലേക്ക് ഒരു പുതിയ ജാവ ഫയൽ ചേർക്കുമ്പോൾ mmake പ്രവർത്തിപ്പിക്കേണ്ടതില്ല. നിങ്ങൾക്ക് ചേർക്കാം
നിങ്ങൾക്ക് ഇഷ്ടമുള്ളത്ര പുതിയ ജാവ ഫയലുകൾ, Makefile അവ കണ്ടെത്തും. ഇത്രയും കാലം ഇതാണ് അവസ്ഥ
നിങ്ങൾ ഒരു പുതിയ പാക്കേജ് ചേർക്കാത്തതിനാൽ. അങ്ങനെയെങ്കിൽ, നിങ്ങൾ ഒന്നുകിൽ mmake വീണ്ടും റൺ ചെയ്യണം അല്ലെങ്കിൽ അപ്ഡേറ്റ് ചെയ്യണം
Makefile-ലെ PACKAGE വേരിയബിൾ. കാരണം, Makefile ഈ വേരിയബിൾ ഉപയോഗിക്കുന്നു
ജാവ ഫയലുകളുള്ള ഡയറക്ടറികൾ കണ്ടെത്തുക.

നിങ്ങളുടെ ജാവ ഫയലുകൾക്കായി ഒരു ഡിപൻഡൻസി ഗ്രാഫ് സൃഷ്‌ടിക്കാൻ പ്രോഗ്രാമിന് mmake-ന് കഴിയും. ഇത് ചെയ്യുന്നതിന്, അത്
ആവശ്യമാണ് തമാശകൾ IBM-ൽ നിന്നുള്ള കമ്പൈലർ. നിന്ന് jikes നേടുക
http://www.ibm.com/developerworks/oss/jikes/.നിങ്ങൾ തമാശകളിൽ കൂടുതൽ സംതൃപ്തരായിരിക്കും
എന്തായാലും, ഇത് javac നേക്കാൾ വളരെ വേഗതയുള്ളതിനാൽ. ഒരു ഡിപൻഡൻസി ഗ്രാഫ് സൃഷ്ടിക്കാൻ, a ചെയ്യുക ഉണ്ടാക്കുക
വെടിപ്പുള്ള ഓടുന്നതിന് മുമ്പ് ഉണ്ടാക്കുക ആശ്രയിക്കുന്നു.

A കുറിപ്പ് ON ഇൻസ്റ്റലേഷൻ

mmake ഉപയോഗിച്ച് സൃഷ്‌ടിച്ച Makefile വ്യത്യസ്ത ഫയലുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിൽ ന്യായമായ ജോലി ചെയ്യും
നിങ്ങളുടെ സിസ്റ്റം ഉണ്ടാക്കുന്നു. ഇത് നടത്തുമ്പോൾ ഇനിപ്പറയുന്ന Makefile വേരിയബിളുകൾ ഉപയോഗിക്കുന്നു
ഇൻസ്റ്റാൾ പതിവ്:

· പ്രിഫിക്സ്

· CLASS_DIR

· JAR_DIR

· BUNDLE_DIR

· DOC_DIR

· SCRIPT_DIR

പ്രിഫിക്‌സ്

ഈ വേരിയബിൾ മുകളിലുള്ള മറ്റെല്ലാ ഡയറക്‌ടറി വേരിയബിളുകളിലേക്കും പ്രെപെൻഡ് ചെയ്യപ്പെടും. ഇതിനായി ഉപയോഗിക്കുന്നു
മറ്റ് ഡയറക്‌ടറികളെ ഒരു റൂട്ട് ഡയറക്‌ടറിയിലേക്ക് ഗ്രൂപ്പുചെയ്യുന്നു. നിങ്ങൾക്ക് അത് ആവശ്യമില്ലെങ്കിൽ, നിങ്ങൾക്ക് ചെയ്യാം
Makefile-ൽ വേരിയബിൾ ഒരു ശൂന്യമായ സ്ട്രിംഗായി സജ്ജമാക്കുക. വേരിയബിൾ നിങ്ങളെ ശൂന്യമാണെങ്കിൽ
നിങ്ങൾ make പ്രവർത്തിപ്പിക്കുമ്പോൾ അത് ഇപ്പോഴും കമാൻഡ് ലൈനിൽ ഉപയോഗിക്കാം, ഉദാഹരണത്തിന് ഒറ്റ ഷൂട്ടിന്
ഇതുപോലുള്ള ഇൻസ്റ്റാളേഷൻ: ഉണ്ടാക്കുക PREFIX=/local/myproject/ ഇൻസ്റ്റാൾ ചെയ്യുക

CLASS_DIR

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

അത്തരം ഫയലുകൾ a-ൽ ഉണ്ടെങ്കിൽ ഈ ഡയറക്‌ടറിക്ക് താഴെ റിസോഴ്‌സ് ഫയലുകളും ഇൻസ്റ്റാൾ ചെയ്യപ്പെടും
പാക്കേജ് ഘടന. നിങ്ങളുടെ പ്രാദേശികവൽക്കരിക്കാൻ നിങ്ങൾ ResourceBundles ഉപയോഗിക്കുകയാണെങ്കിൽ ഇത് ഉപയോഗപ്രദമാണ്
ആപ്ലിക്കേഷൻ, പാക്കേജ് ഘടനയിലെ സ്വന്തം ഡയറക്ടറിയിൽ നിങ്ങളുടെ പ്രോപ്പർട്ടി ഫയലുകൾ ഉണ്ടായിരിക്കുക.

JAR_DIR

ജാർ ഫയൽ എവിടെ ഇൻസ്റ്റാൾ ചെയ്യണമെന്ന് ഈ വേരിയബിൾ Makefile-നോട് പറയുന്നു. സ്ഥിര മൂല്യം ആണ് ലിബ്,
ഒരു നല്ല ഡിഫോൾട്ട് മൂല്യം കൂടിയാണിത്.

BUNDLE_DIR

ആപ്പ് ബണ്ടിൽ എവിടെ ഇൻസ്റ്റാൾ ചെയ്യണമെന്ന് ഈ വേരിയബിൾ Makefile-നോട് പറയുന്നു. സ്ഥിര മൂല്യം ആണ്
ലിബ്, ഇത് ഒരു നല്ല ഡിഫോൾട്ട് മൂല്യം കൂടിയാണ്.

DOC_DIR

നിങ്ങൾ javadoc പ്രവർത്തിപ്പിക്കുമ്പോൾ, എല്ലാ html ഫയലുകളും ഈ ഡയറക്ടറിയിൽ ഇടും. അതിന്റെ സ്ഥിരസ്ഥിതി
മൂല്യം doc/api-docs. നിങ്ങൾ ഒരുപക്ഷേ ആ പേര് നിലനിർത്തണം, എന്നാൽ വീണ്ടും, നിങ്ങൾക്ക് മാറിയേക്കാം
നിന്റെ ഇഷ്ടം പോലെ.

SCRIPT_DIR

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

ഇൻസ്റ്റലേഷൻ സംഗ്രഹം

നിങ്ങൾ സ്ഥിരസ്ഥിതി മൂല്യങ്ങൾ സൂക്ഷിക്കുകയാണെങ്കിൽ, ഇതുപോലെയുള്ള ഒരു ഇൻസ്റ്റലേഷൻ ട്രീ നിങ്ങൾക്ക് ലഭിക്കും:

`-- പ്രിഫിക്സ്
⎪-- ബിൻ
⎪-- ക്ലാസുകൾ
⎪ `-- പാക്കേജ് <--- ഒരു ഉപ-ഡയറക്‌ടറിയുടെ ഉദാഹരണം
⎪ ⎪-- ഉപപാക്കേജ്1
⎪ ⎪-- ഉപപാക്കേജ്2
⎪ `-- ഉപ-പാക്കേജ്3
⎪-- ഡോക്
⎪ `-- api-docs
`-- ലിബ്

ഉപയോഗിക്കുന്നു ദി സി-പ്രോപ്രോസസർ

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

ജാവയ്‌ക്കൊപ്പം C പ്രീപ്രൊസസ്സർ ഉപയോഗിക്കുന്നതിന്, നിങ്ങൾക്ക് ഉറവിട ഫയലുകളുടെ പേര് മാറ്റാവുന്നതാണ്
നിങ്ങൾ മുൻകൂട്ടി പ്രോസസ്സ് ചെയ്യാൻ ആഗ്രഹിക്കുന്നത് -- നിന്ന് .ജാവ വരെ .xjava. Makefile ഉണ്ട്
.xjava ഫയലുകളിൽ നിന്ന് .class ഫയലുകൾ നിർമ്മിക്കുന്നതിനുള്ള ഒരു നിയമം.

അത് അല്ല എല്ലാ ഫയലുകളും .java-ൽ നിന്ന് .xjava-ലേക്ക് മാറ്റേണ്ടതുണ്ട്. Makefile നന്നായി പ്രവർത്തിക്കും
.java, .xjava ഫയലുകളുടെ പരിതസ്ഥിതിയിൽ സ്ഥിരമായി. (ഉദാ: 'വൃത്തിയാക്കുക' എന്ന ഇച്ഛ
ഒരു .xjava ഫയലിൽ നിന്ന് സൃഷ്ടിച്ച .java ഫയലുകൾ മാത്രം നീക്കം ചെയ്യുക. മറ്റ് ജാവ ഫയലുകൾ ചെയ്യും
കോഴ്സ്, അല്ല നീക്കം ചെയ്യണം.)

നിങ്ങൾക്ക് ഇപ്പോൾ നിങ്ങളുടെ ജാവ-കോഡിൽ cpp സോപാധികങ്ങൾ ഉപയോഗിക്കാം, ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്നത് പോലെ:

#ifdef JAVA1_1
[കോഡ്1]
# കൂടാതെ
[കോഡ്2]
#അവസാനം

മുകളിലെ ഉദാഹരണത്തിലെ JAVA1_1 ലേബൽ VERSION വേരിയബിളിനെതിരെ പരീക്ഷിച്ചു
മേക്ക് ഫയൽ. അതായത്, VERSION വേരിയബിൾ JAVA1_1 ആണെങ്കിൽ, [code1] കംപൈൽ ചെയ്യപ്പെടും.
[code2] വിട്ടുപോയി. അതുപോലെ, VERSION JAVA1_1 അല്ലാതെ മറ്റെന്തെങ്കിലും ആണെങ്കിൽ, [code2] ചെയ്യും
കംപൈൽ ചെയ്യുകയും [code1] ഫലമായുണ്ടാകുന്ന .class ഫയലിൽ നിന്ന് ഒഴിവാക്കുകയും ചെയ്യും.

കുറിപ്പുകൾ

mmake നിങ്ങൾക്ക് തരും ഒന്ന് നിങ്ങളുടെ Java ഫയലുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള Makefile. ഇത് എളുപ്പമാണെങ്കിലും
റിക്കേഴ്‌സീവ് മേക്ക്‌ഫൈൽ സന്ദർഭത്തിൽ mmake സജ്ജീകരിച്ച് ഉപയോഗിക്കുക, നിങ്ങൾ അത് ചെയ്യാൻ ആഗ്രഹിക്കുന്നില്ല. കാണാൻ
എന്തുകൊണ്ട്, മികച്ച ലേഖനം വായിക്കുക: ആവർത്തന ഉണ്ടാക്കുക കണക്കാക്കുന്നു ഹാനികരമായ at
http://www.canb.auug.org.au/~millerp/rmch/recu-make-cons-harm.html

ഡിപൻഡൻസികൾ

mmake ഇനിപ്പറയുന്നവ ആവശ്യമാണ്:

· പേൾ 5.x

· ഗ്നു ഉണ്ടാക്കുക

· Gnu xargs (ശുപാർശ ചെയ്യുന്നു)

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