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

പട്ടിക:

NAME

emcc - എംസ്ക്രിപ്റ്റൻ കമ്പൈലർ ഫ്രണ്ട്എൻഡ്

വിവരണം

emcc [ഓപ്ഷനുകൾ] ഫയൽ...

ഏറ്റവും സാധാരണ gcc/g++ ഓപ്ഷനുകൾ ഉദ്ദേശിക്കുന്ന ജോലി, വേണ്ടി ഉദാഹരണം:
--സഹായിക്കൂ ഈ വിവരം പ്രദർശിപ്പിക്കുക

--പതിപ്പ്
കംപൈലർ പതിപ്പ് വിവരങ്ങൾ പ്രദർശിപ്പിക്കുക

ഓപ്ഷനുകൾ ആ ആകുന്നു തിരുത്തപ്പെട്ടത് or പുതിയ in emcc ഉൾപ്പെടുന്നു:
-O0 ഒപ്റ്റിമൈസേഷനുകളൊന്നുമില്ല (സ്ഥിരസ്ഥിതി)

-O1 asm.js, LLVM ഉൾപ്പെടെയുള്ള ലളിതമായ ഒപ്റ്റിമൈസേഷനുകൾ -O1 ഒപ്റ്റിമൈസേഷനുകൾ, കൂടാതെ റൺടൈം ഇല്ല
അവകാശവാദങ്ങൾ അല്ലെങ്കിൽ C++ ഒഴിവാക്കൽ ക്യാച്ചിംഗ് (C++ ഒഴിവാക്കൽ ക്യാച്ചിംഗ് വീണ്ടും പ്രവർത്തനക്ഷമമാക്കാൻ, ഉപയോഗിക്കുക -s
DISABLE_EXCEPTION_CATCHING=0 ). (വ്യത്യസ്ത ഓപ്‌റ്റുകളുടെ സ്വാധീനത്തെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾക്ക്
ലെവലുകൾ, tools/shared.py എന്നതിലെ apply_opt_level() കാണുക, കൂടാതെ src/settings.js.) ശ്രദ്ധിക്കുക:
JavaScript-ലേക്ക് കംപൈൽ ചെയ്യുമ്പോൾ മാത്രമേ ഒപ്റ്റിമൈസേഷനുകൾ ചെയ്യൂ, ഇന്റർമീഡിയറ്റിലേക്കല്ല
ബിറ്റ്കോഡ്, *നിങ്ങൾ EMCC_OPTIMIZE_NORMALLY=1 ഉപയോഗിച്ച് നിർമ്മിക്കുന്നില്ലെങ്കിൽ* (ശുപാർശ ചെയ്യുന്നില്ല
നിങ്ങൾ എന്താണ് ചെയ്യുന്നതെന്ന് നിങ്ങൾക്കറിയാം!)

-O2 As -O1, കൂടാതെ റീലൂപ്പർ (ലൂപ്പ് റിക്രിയേഷൻ), LLVM -O2 ഒപ്റ്റിമൈസേഷനുകൾ, കൂടാതെ

-s ALIASING_FUNCTION_POINTERS=1

-O3 As -O2, കൂടാതെ ജനറേറ്റുചെയ്‌ത കോഡ് തകർത്തേക്കാവുന്ന അപകടകരമായ ഒപ്റ്റിമൈസേഷനുകളും! ഇത് കൂട്ടിച്ചേർക്കുന്നു

-s FORCE_ALIGNED_MEMORY=1 -s DOUBLE_MODE=0 -s PRECISE_I64_MATH=0 --അടയ്ക്കൽ 1
--llvm-lto 1

ഇത് ഒട്ടും ശുപാർശ ചെയ്യുന്നില്ല. ഇവ ഓരോന്നും വെവ്വേറെ പരീക്ഷിക്കുക എന്നതാണ് ഒരു മികച്ച ആശയം
മുകളിൽ -O2 എന്താണ് പ്രവർത്തിക്കുന്നതെന്ന് കാണാൻ. വിക്കി, src/settings.js എന്നിവ കാണുക (ഇതിനായി -s ഓപ്ഷനുകൾ)
കൂടുതൽ വിവരങ്ങൾക്ക്.

-s ഓപ്‌ഷൻ=മൂല്യം
JavaScript കോഡ് ജനറേഷൻ ഓപ്ഷൻ എംസ്ക്രിപ്റ്റൻ കംപൈലറിലേക്ക് കടന്നു. വേണ്ടി
ലഭ്യമായ ഓപ്‌ഷനുകൾ, src/settings.js കാണുക, ലിസ്‌റ്റുകളുള്ള ഓപ്‌ഷനുകൾക്കായി നിങ്ങൾ ശ്രദ്ധിക്കുക
മിക്ക ഷെല്ലുകളിലും ഉദ്ധരണി ചിഹ്നങ്ങൾ ആവശ്യമാണ്, ഉദാഹരണത്തിന്

-s RUNTIME_LINKED_LIBS="['liblib.so']"

or

-s "RUNTIME_LINKED_LIBS=['liblib.so']"

(അവ രണ്ടിലും ബാഹ്യമായ "കൾ ഇല്ലെങ്കിൽ, നിങ്ങൾക്ക് ഒരു പിശക് ലഭിക്കും)

മൂല്യം വായിക്കേണ്ട ഒരു ഫയലും നിങ്ങൾക്ക് വ്യക്തമാക്കാം, ഉദാഹരണത്തിന്,

-s DEAD_FUNCTIONS=@/path/to/file

ന്റെ ഉള്ളടക്കം /path/to/file വായിക്കുകയും JSON.പാഴ്‌സ് ചെയ്യുകയും DEAD_FUNCTIONS ആയി സജ്ജീകരിക്കുകയും ചെയ്യും
(അതിനാൽ ഫയലിൽ അടങ്ങിയിരിക്കാം

["_func1", "func2"]

). പാത ആപേക്ഷികമല്ല, കേവലമായിരിക്കണം എന്നത് ശ്രദ്ധിക്കുക.

-g ഡീബഗ് വിവരം ഉപയോഗിക്കുക. മുതലുള്ള അവസാന സമാഹരണ ഘട്ടത്തിൽ നിങ്ങൾക്ക് ഇത് ആവശ്യമാണെന്ന് ശ്രദ്ധിക്കുക
JavaScript-ലേക്കുള്ള ബിറ്റ്കോഡ്, അല്ലെങ്കിൽ ഞങ്ങൾ അത് ഡിഫോൾട്ടായി നീക്കം ചെയ്യും -O1 മുകളിൽ. ഇൻ
-O0, ലൈൻ നമ്പറുകൾ ജനറേറ്റ് ചെയ്ത കോഡിൽ കാണിക്കും. ഇൻ -O1 മുകളിൽ, ദി
ഒപ്റ്റിമൈസർ ആ കമന്റുകൾ നീക്കം ചെയ്യുന്നു. എന്നിരുന്നാലും, ഈ പതാകയ്ക്ക് ഫലമുണ്ട്
നെയിം മാംഗ്ലിംഗിനോ ചെറുതാക്കലിനോ കാരണമാകുന്ന എന്തും പ്രവർത്തനരഹിതമാക്കുന്നു (അടയ്ക്കൽ അല്ലെങ്കിൽ
പാസ് രജിസ്റ്റർ ചെയ്യുക).

--ടൈപ്പ് ചെയ്ത അറേകൾ
0: ടൈപ്പ് ചെയ്‌ത അറേകൾ ഇല്ല 1: സമാന്തരമായി ടൈപ്പ് ചെയ്‌ത അറേകൾ 2: പങ്കിട്ട (സി പോലെയുള്ള) ടൈപ്പ് ചെയ്‌ത അറേകൾ
(സ്ഥിരസ്ഥിതി)

--llvm-opts
0: LLVM ഒപ്റ്റിമൈസേഷനുകളൊന്നുമില്ല (ഡിഫോൾട്ട് ഇൻ -O0) 1: -O1 LLVM ഒപ്റ്റിമൈസേഷനുകൾ (ഡിഫോൾട്ട് ഇൻ
-O1) 2: -O2 LLVM ഒപ്റ്റിമൈസേഷനുകൾ 3: -O3 LLVM ഒപ്റ്റിമൈസേഷനുകൾ (ഡിഫോൾട്ട് ഇൻ -O2+)

--llvm-lto
0: LLVM LTO ഇല്ല (ഡിഫോൾട്ട് ഇൻ -O2 കൂടാതെ താഴെ) 1: LLVM LTO (ഡിഫോൾട്ട് ഇൻ -O3) ശ്രദ്ധിക്കുക: എങ്കിൽ
LLVM ഒപ്റ്റിമൈസേഷനുകൾ റൺ ചെയ്തിട്ടില്ല (കാണുക --llvm-opts), ഇത് 1 ആക്കി വെച്ചാൽ ഫലമില്ല.

--അടയ്ക്കൽ
0: ക്ലോഷർ കംപൈലർ ഇല്ല (ഡിഫോൾട്ട് ഇൻ -O2 കൂടാതെ താഴെ) 1: ക്ലോഷർ കംപൈലർ പ്രവർത്തിപ്പിക്കുക. ഈ
കോഡ് വലുപ്പം വളരെയധികം കുറയ്ക്കുകയും ചില സന്ദർഭങ്ങളിൽ റൺടൈം വേഗത വർദ്ധിപ്പിക്കുകയും ചെയ്തേക്കാം (എന്നിരുന്നാലും
വിപരീതവും സംഭവിക്കാം). ഇത് പ്രവർത്തിപ്പിക്കാൻ സമയമെടുക്കുമെന്നത് ശ്രദ്ധിക്കുക, ചിലത് ആവശ്യമായി വന്നേക്കാം
കോഡിലെ മാറ്റങ്ങൾ. ഇത് സ്ഥിരസ്ഥിതിയായി പ്രവർത്തിക്കുന്നു -O3.

asm.js മോഡിൽ, സമാഹരിച്ചതിന് ചുറ്റുമുള്ള 'ഷെൽ' കോഡിൽ മാത്രമേ ക്ലോഷർ ഉപയോഗിക്കൂ.
കോഡ് (കംപൈൽ ചെയ്ത കോഡ് ഇഷ്‌ടാനുസൃത asm.js മിനിഫയർ പ്രോസസ്സ് ചെയ്യും).

ശ്രദ്ധിക്കുക: ക്ലോഷർ കംപൈലർ മെമ്മറിക്ക് പുറത്താണെങ്കിൽ, JAVA_HEAP_SIZE ക്രമീകരിക്കാൻ ശ്രമിക്കുക
പരിസ്ഥിതി (ഉദാഹരണത്തിന്, 4096GB ന് 4m വരെ).

--js-പരിവർത്തനം
ഒപ്റ്റിമൈസ് ചെയ്യുന്നതിനുമുമ്പ് ജനറേറ്റ് ചെയ്ത കോഡിൽ വിളിക്കും. ഇത് നിങ്ങളെ അനുവദിക്കുന്നു
ജാവാസ്ക്രിപ്റ്റ് പരിഷ്ക്കരിക്കുക, ഉദാഹരണത്തിന് കുറച്ച് കോഡ് ചേർക്കുകയോ ചില കോഡ് നീക്കം ചെയ്യുകയോ ചെയ്യുക
ജനറേറ്റ് ചെയ്‌ത കോഡിനൊപ്പം ആ പരിഷ്‌ക്കരണങ്ങൾ ഒപ്റ്റിമൈസ് ചെയ്യപ്പെടും
ശരിയായി. ജനറേറ്റ് ചെയ്‌ത കോഡിന്റെ ഫയൽനാമം a ആയി വിളിക്കും
പരാമീറ്റർ; കോഡ് പരിഷ്‌ക്കരിക്കുന്നതിന്, നിങ്ങൾക്ക് യഥാർത്ഥ ഡാറ്റ വായിച്ച് അതിൽ ചേർക്കാം
അല്ലെങ്കിൽ പരിഷ്കരിച്ച ഡാറ്റ ഉപയോഗിച്ച് തിരുത്തിയെഴുതുക. ഒരു സ്പേസ് വേർതിരിക്കുന്നതായി വ്യാഖ്യാനിക്കപ്പെടുന്നു
വാദങ്ങളുടെ പട്ടിക, ഉദാഹരണത്തിന്, "python processor.py" ഒരു പൈത്തണിന് കാരണമാകും
സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കണം.

--പ്രീ-ജെഎസ്
ജനറേറ്റ് ചെയ്‌ത കോഡിന് മുമ്പ് ഉള്ളടക്കം ചേർത്ത ഒരു ഫയൽ. ഇത് *മുമ്പ്* ചെയ്തു
ഒപ്റ്റിമൈസേഷൻ, അതിനാൽ ക്ലോഷർ കംപൈലർ പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ അത് ശരിയായി ചെറുതാക്കും.

--പോസ്റ്റ്-ജെഎസ്
ജനറേറ്റ് ചെയ്ത കോഡിന് ശേഷം ഉള്ളടക്കം ചേർത്ത ഒരു ഫയൽ ഇത് *മുമ്പ്* ചെയ്യുന്നു
ഒപ്റ്റിമൈസേഷൻ, അതിനാൽ ക്ലോഷർ കംപൈലർ പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ അത് ശരിയായി ചെറുതാക്കും.

--എംബെഡ്-ഫയൽ
ജനറേറ്റ് ചെയ്‌ത JavaScript-ന്റെ ഉള്ളിൽ ഉൾച്ചേർക്കാനുള്ള ഒരു ഫയൽ. സമാഹരിച്ച കോഡിന് കഴിയും
ഇവിടെ നൽകിയിരിക്കുന്ന അതേ പേരിൽ നിലവിലെ ഡയറക്ടറിയിൽ ഫയൽ ആക്സസ് ചെയ്യുക. അങ്ങനെയാണെങ്കില്
നീ ചെയ്യുക --എംബെഡ്-ഫയൽ dir/file.dat, തുടർന്ന് (1) dir/file.dat ആപേക്ഷികമായി നിലനിൽക്കണം
നിങ്ങൾ emcc പ്രവർത്തിപ്പിക്കുന്നിടത്ത്, (2) നിങ്ങളുടെ കംപൈൽ ചെയ്ത കോഡിന് ഫയൽ കണ്ടെത്താൻ കഴിയും
അതേ പാത വായിക്കുന്നു, dir/file.dat. ഇവിടെ ഒരു ഡയറക്‌ടറി പാസ്സാക്കിയാൽ, അതിന്റെ മുഴുവൻ
ഉള്ളടക്കങ്ങൾ ഉൾച്ചേർക്കപ്പെടും.

--പ്രീലോഡ്-ഫയൽ
കംപൈൽ ചെയ്ത കോഡ് അസമന്വിതമായി പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ് പ്രീലോഡ് ചെയ്യേണ്ട ഒരു ഫയൽ. അല്ലെങ്കിൽ
ഇതുപോലെയാണ് --എംബെഡ്-ഫയൽ, സൃഷ്ടിക്കുമ്പോൾ മാത്രമേ ഈ ഓപ്ഷൻ പ്രസക്തമാകൂ എന്നതൊഴിച്ചാൽ
HTML (ഇത് അസിൻക്രണസ് ബൈനറി XHR-കൾ ഉപയോഗിക്കുന്നു), അല്ലെങ്കിൽ ഒരു വെബ് പേജിൽ ഉപയോഗിക്കുന്ന JS. എങ്കിൽ
ഒരു ഡയറക്‌ടറി ഇവിടെ പാസാക്കുന്നു, അതിലെ മുഴുവൻ ഉള്ളടക്കങ്ങളും പ്രീലോഡ് ചെയ്യപ്പെടും. പ്രീലോഡ് ചെയ്ത ഫയലുകൾ
filename.data എന്നതിൽ സംഭരിച്ചിരിക്കുന്നു, ഇവിടെ filename.html ആണ് നിങ്ങൾ കംപൈൽ ചെയ്യുന്ന പ്രധാന ഫയൽ
വരെ. നിങ്ങളുടെ കോഡ് പ്രവർത്തിപ്പിക്കുന്നതിന്, നിങ്ങൾക്ക് .html ഉം .data ഉം ആവശ്യമാണ്.

emcc, എംബഡഡ് എന്നിവയുടെ യഥാർത്ഥ പാക്കേജിംഗ് ചെയ്യുന്നതിന് tools/file_packager.py പ്രവർത്തിപ്പിക്കുന്നു
പ്രീലോഡ് ചെയ്ത ഫയലുകൾ. നിങ്ങൾക്ക് വേണമെങ്കിൽ ഫയൽ പാക്കേജർ പ്രവർത്തിപ്പിക്കാം, ഡോക്സ് കാണുക
ആ ഫയലിനുള്ളിൽ. അപ്പോൾ നിങ്ങൾ ഫയൽ പാക്കേജറിന്റെ ഔട്ട്പുട്ട് ഒരു emcc-യിൽ ഇടണം
--പ്രീ-ജെഎസ്, അതുവഴി നിങ്ങളുടെ പ്രധാന കംപൈൽ ചെയ്ത കോഡിന് മുമ്പായി അത് എക്സിക്യൂട്ട് ചെയ്യുന്നു (അല്ലെങ്കിൽ മുമ്പായി അത് പ്രവർത്തിപ്പിക്കുക
മറ്റെന്തെങ്കിലും വഴി).

--കംപ്രഷൻ
കംപൈൽ ചെയ്‌ത കോഡും ഉൾച്ചേർത്ത/ പ്രീലോഡ് ചെയ്‌ത ഫയലുകളും കംപ്രസ് ചെയ്യുക. എ ആയിരിക്കണം
ട്രിപ്പിൾ,

, ,

stdin-നെ stdout-ലേക്ക് കംപ്രസ്സുചെയ്യുന്ന നേറ്റീവ് എക്സിക്യൂട്ടബിൾ ആണ് നേറ്റീവ്_എൻകോഡർ.
സാധ്യമായ ഏറ്റവും ലളിതമായ ഇന്റർഫേസ്), a നടപ്പിലാക്കുന്ന ഒരു JavaScript ഫയലാണ് js_decoder
ഡീകോഡർ, കൂടാതെ js_name എന്നത് ഡീകോഡർ ഫയലിൽ വിളിക്കേണ്ട ഫംഗ്ഷന്റെ പേരാണ് (ഏത്
ഒരു അറേ/ടൈപ്പ് ചെയ്‌ത അറേ ലഭിക്കുകയും ഒരു അറേ/ടൈപ്പ് ചെയ്‌ത അറേ നൽകുകയും വേണം. കംപ്രഷൻ
HTML സൃഷ്ടിക്കുമ്പോൾ മാത്രം പ്രവർത്തിക്കുന്നു. കംപ്രഷൻ ഓണായിരിക്കുമ്പോൾ, എല്ലാം ഫയൽ ചെയ്‌തിരിക്കുന്നു
പ്രീലോഡഡ് ഒരു വലിയ ആർക്കൈവിൽ കംപ്രസ് ചെയ്യുന്നു, അതിന് അതേ പേര് നൽകിയിരിക്കുന്നു
ഔട്ട്‌പുട്ട് HTML എന്നാൽ .data.compress എന്ന പ്രത്യയം

--മിനിഫൈ ചെയ്യുക
0: ജനറേറ്റുചെയ്‌ത JavaScript-ന്റെ വൈറ്റ്‌സ്‌പെയ്‌സ് ചെറുതാക്കരുത് (ഡിഫോൾട്ട് ഇൻ -O0, -O1, അല്ലെങ്കിൽ
-g ഉപയോഗിക്കുന്നത്)

1: ജനറേറ്റുചെയ്‌ത JavaScript-കൾ ചെറുതാക്കുക

വൈറ്റ്‌സ്‌പെയ്‌സ് (ഡിഫോൾട്ട് ഇൻ -O2+, അനുമാനിക്കുന്നു -g ഉപയോഗിച്ചിട്ടില്ല)

--രണ്ടായി പിരിയുക
ഡീബഗ്ഗിംഗ് എളുപ്പമാക്കാൻ തത്ഫലമായുണ്ടാകുന്ന ജാവാസ്ക്രിപ്റ്റ് ഫയലിനെ കഷണങ്ങളായി വിഭജിക്കുന്നു. ഈ ഓപ്ഷൻ
Javascript സൃഷ്ടിച്ചാൽ മാത്രമേ പ്രവർത്തിക്കൂ (ലക്ഷ്യം -o .js). ഫംഗ്ഷനുള്ള ഫയലുകൾ
എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ പ്രധാന ഫയലിന് മുമ്പായി ഡിക്ലറേഷനുകൾ ലോഡ് ചെയ്യണം.

"-g" ഓപ്ഷൻ ഇല്ലാതെ:

സഫിക്‌സ് ഉപയോഗിച്ച് നൽകിയിരിക്കുന്ന വലുപ്പം വരെയുള്ള ഫംഗ്‌ഷൻ ഡിക്ലറേഷനുകളുള്ള ഫയലുകൾ സൃഷ്‌ടിക്കുന്നു
"_functions.partxxx.js" കൂടാതെ ".js" എന്ന പ്രത്യയമുള്ള ഒരു പ്രധാന ഫയലും.

"-g" ഓപ്ഷൻ ഉപയോഗിച്ച്:

സി സോഴ്‌സ് ഫയലുകളുടെയും സ്റ്റോറുകളുടെ പ്രവർത്തനത്തിന്റെയും ഡയറക്ടറി ഘടന പുനഃസൃഷ്ടിക്കുന്നു
".js" എന്ന പ്രത്യയം ഉപയോഗിച്ച് അതത് C ഫയലുകളിലെ പ്രഖ്യാപനങ്ങൾ. അത്തരമൊരു ഫയൽ ആണെങ്കിൽ
നൽകിയിരിക്കുന്ന വലുപ്പം കവിയുന്നു, ".partxxx.js" എന്ന പ്രത്യയം ഉള്ള ഫയലുകൾ സൃഷ്ടിക്കപ്പെടുന്നു. പ്രധാനപ്പെട്ട
ഫയൽ അടിസ്ഥാന ഡയറക്ടറിയിൽ വസിക്കുന്നു, കൂടാതെ ".js" എന്ന പ്രത്യയം ഉണ്ട്.

--കെട്ടുക C/C++ ബന്ധിപ്പിക്കുന്ന "എംബൈൻഡ്" ബൈൻഡിംഗ് സമീപനം ഉപയോഗിച്ച് സോഴ്സ് കോഡ് കംപൈൽ ചെയ്യുന്നു
കൂടാതെ ജെ.എസ്.

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

--ഷെൽ-ഫയൽ
HTML ഔട്ട്പുട്ട് സൃഷ്ടിക്കുമ്പോൾ ഉപയോഗിക്കുന്ന ഒരു അസ്ഥികൂടം HTML ഫയലിലേക്കുള്ള പാതയുടെ പേര്. ഷെൽ
ഉപയോഗിച്ച ഫയലിൽ ഈ ടോക്കൺ ഉണ്ടായിരിക്കണം: {{{ SCRIPT_CODE }}} ഇത് ശ്രദ്ധിക്കുക
HTML അല്ലാതെ മറ്റൊരു ടാർഗെറ്റ് ഉപയോഗിച്ച് വ്യക്തമാക്കിയാൽ ആർഗ്യുമെന്റ് അവഗണിക്കപ്പെടും -o ഓപ്ഷൻ.

--js-ലൈബ്രറി
എംസ്‌ക്രിപ്റ്റന്റെ src/library_*-ൽ ഉള്ളവ കൂടാതെ ഉപയോഗിക്കാനുള്ള ഒരു JavaScript ലൈബ്രറി

-v വെർബോസ് ഔട്ട്പുട്ട് ഓണാക്കുന്നു. ഇത് കടന്നുപോകും -v ക്ലാങ്ങിലേക്ക്, കൂടാതെ EMCC_DEBUG പ്രവർത്തനക്ഷമമാക്കുക
emcc യുടെ പ്രവർത്തനങ്ങളുടെ വിശദാംശങ്ങൾ

--jcache
ഒരു JavaScript കാഷെ ഉപയോഗിക്കുക. ഇത് സ്ഥിരസ്ഥിതിയായി പ്രവർത്തനരഹിതമാക്കിയിരിക്കുന്നു. പ്രവർത്തനക്ഷമമാക്കുമ്പോൾ, emcc സംഭരിക്കും
ഒരു കാഷെയിൽ സമാഹരിച്ചതിന്റെ ഫലങ്ങൾ പിന്നീട് കംപൈൽ ചെയ്യുമ്പോൾ കാഷെ പരിശോധിക്കുക,
കാഷെ ചെയ്യുന്നത് പോലെ ഒന്ന്. ഇത് ഇൻക്രിമെന്റൽ ബിൽഡുകൾ അനുവദിക്കുന്നു - നിങ്ങൾ എവിടെയാണ്
ഒരു വലിയ പ്രോഗ്രാം കംപൈൽ ചെയ്യുന്നു, പക്ഷേ അതിന്റെ ഒരു ചെറിയ ഭാഗം മാത്രമേ പരിഷ്കരിച്ചിട്ടുള്ളൂ - വളരെ വേഗത്തിൽ
(കാഷെ ആക്‌സസ്സുകൾക്കായുള്ള കൂടുതൽ ഡിസ്‌ക് ഐഒയുടെ ചിലവിൽ). നിങ്ങൾ പ്രവർത്തനക്ഷമമാക്കേണ്ടതുണ്ടെന്ന കാര്യം ശ്രദ്ധിക്കുക
--jcache ഡാറ്റ ലോഡുചെയ്യുന്നതിനും സംരക്ഷിക്കുന്നതിനും, അതിനാൽ നിങ്ങൾ ഇത് ഒരു പൂർണ്ണ ബിൽഡിൽ പ്രവർത്തനക്ഷമമാക്കണം
പിന്നീടുള്ള ഇൻക്രിമെന്റൽ ബിൽഡിനായി (നിങ്ങളും ഇത് പ്രാപ്തമാക്കുന്നിടത്ത്) വേഗത്തിലാക്കാൻ.

കംപൈലേഷന്റെ 4 ഭാഗങ്ങളിൽ കാഷിംഗ് വെവ്വേറെ പ്രവർത്തിക്കുന്നു: തരങ്ങളും ആഗോളവുമായ 'പ്രീ'
വേരിയബിളുകൾ; ആ വിവരങ്ങൾ പിന്നീട് ഫംഗ്‌ഷനുകളായ 'ഫങ്കുകളിലേക്ക്' നൽകപ്പെടുന്നു (ഏത്
ഞങ്ങൾ സമാന്തരമാക്കുന്നു), തുടർന്ന് 'പോസ്റ്റ്' അടിസ്ഥാനമാക്കി അന്തിമ വിവരങ്ങൾ ചേർക്കുന്നു
ഫംഗ്‌ഷനുകൾ (ഉദാ, നമുക്ക് long64 പിന്തുണ കോഡ് ആവശ്യമുണ്ടോ). അവസാനമായി, 'jsfuncs' ആണ്
JavaScript-ലെവൽ ഒപ്റ്റിമൈസേഷനുകൾ. 4 ഭാഗങ്ങളിൽ ഓരോന്നും പ്രത്യേകം കാഷെ ചെയ്യാം, പക്ഷേ
അവ പരസ്പരം ബാധിക്കുമെന്നത് ശ്രദ്ധിക്കുക: നിങ്ങൾ ഒരൊറ്റ C++ ഫയൽ വീണ്ടും കംപൈൽ ചെയ്യുകയാണെങ്കിൽ
ഒരു ഗ്ലോബൽ വേരിയബിൾ മാറ്റുന്നു - ഉദാ, ഒരു ഗ്ലോബൽ വേരിയബിൾ കൂട്ടിച്ചേർക്കുക, നീക്കം ചെയ്യുക അല്ലെങ്കിൽ പരിഷ്ക്കരിക്കുക, പറയുക
ഒരു പ്രിന്റ് എഫ് ചേർക്കുന്നതിലൂടെയോ കംപൈൽ-ടൈം സ്റ്റാമ്പ് ചേർക്കുന്നതിലൂടെയോ, 'പ്രീ' ആകാൻ കഴിയില്ല
കാഷെയിൽ നിന്ന് ലോഡ് ചെയ്തു. കൂടാതെ 'പ്രീയുടെ ഔട്ട്‌പുട്ട് 'ഫങ്കുകൾ', 'പോസ്റ്റ്' എന്നിവയിലേക്ക് അയയ്‌ക്കുന്നതിനാൽ, അവ
അസാധുവാകും, കൂടാതെ 'jsfuncs' മാത്രം കാഷെ ചെയ്യപ്പെടും. അതിനാൽ പരിഷ്ക്കരിക്കുന്നത് ഒഴിവാക്കുക
ആഗോളതലത്തിൽ കാഷിംഗ് പൂർണ്ണമായും പ്രവർത്തിക്കാൻ അനുവദിക്കുക.

മുമ്പത്തെ ഖണ്ഡികയിൽ പറഞ്ഞിരിക്കുന്ന പ്രശ്നം പരിഹരിക്കാൻ, നിങ്ങൾക്ക് ഉപയോഗിക്കാം

emscripten_jcache_printf

നിങ്ങളുടെ കോഡിലേക്ക് debug printfs ചേർക്കുമ്പോൾ. ആ ഫംഗ്‌ഷൻ പ്രത്യേകമായി മുൻകൂട്ടി പ്രോസസ്സ് ചെയ്‌തതാണ്
അതിന്റെ ആദ്യ ആർഗ്യുമെന്റിന് ആഗോള സ്ഥിരമായ ഒരു സ്ട്രിംഗ് സൃഷ്ടിക്കുന്നില്ല. കാണുക
കൂടുതൽ വിവരങ്ങൾക്ക് emscripten.h. നിങ്ങൾക്ക് ഇതിനകം ഒരു ഉണ്ടായിരിക്കണമെന്ന് പ്രത്യേകം ശ്രദ്ധിക്കുക
നിങ്ങളുടെ കോഡിൽ ആ ഫംഗ്‌ഷനിലേക്ക് വിളിക്കുക *മുമ്പ്* നിങ്ങൾ ഒന്ന് ചേർത്ത് ഒരു ഇൻക്രിമെന്റൽ ചെയ്യുക
ബിൽഡ്, അങ്ങനെ ഒരു ബാഹ്യ റഫറൻസ് (ഒരു ആഗോള സ്വത്ത്) ചേർക്കുന്നില്ല
എല്ലാം അസാധുവാക്കുക.

നിങ്ങൾ ഉപയോഗിക്കേണ്ടത് ശ്രദ്ധിക്കുക -g ലിങ്കിംഗ് ഘട്ടത്തിൽ (JS-ലേക്കുള്ള ബിറ്റ്കോഡ്), jcache-ലേക്ക്
പ്രവർത്തിക്കുക (അല്ലെങ്കിൽ, JS മിനിഫിക്കേഷൻ അതിനെ ആശയക്കുഴപ്പത്തിലാക്കും).

--കാഷെ മായ്‌ക്കുക
സമാഹരിച്ച എംസ്ക്രിപ്റ്റൻ സിസ്റ്റം ലൈബ്രറികളുടെ കാഷെ സ്വമേധയാ മായ്‌ക്കുന്നു (libc++,
libc++abi, libc). ഇത് സാധാരണയായി സ്വയമേവ കൈകാര്യം ചെയ്യപ്പെടുന്നു, എന്നാൽ നിങ്ങൾ llvm അപ്ഡേറ്റ് ചെയ്യുകയാണെങ്കിൽ
ഇൻ-പ്ലേസ് (ഒരു പുതിയ പതിപ്പിന് മറ്റൊരു ഡയറക്‌ടറി ഉണ്ടായിരിക്കുന്നതിനുപകരം), കാഷിംഗ്
മെക്കാനിസം ആശയക്കുഴപ്പത്തിലാകാം. കാഷെ മായ്ക്കുന്നത് ഇതുമായി ബന്ധപ്പെട്ട വിചിത്രമായ പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ കഴിയും
ലൈബ്രറി ഫയലുകളുമായി ലിങ്ക് ചെയ്യുന്നതിൽ ക്ലാങ് പരാജയപ്പെടുന്നത് പോലെയുള്ള കാഷെ പൊരുത്തക്കേടുകൾ. ഇതും
jcache, bootstrapped relooper എന്നിവ പോലെയുള്ള മറ്റ് കാഷെ ചെയ്ത ഡാറ്റ മായ്‌ക്കുന്നു. ശേഷം
കാഷെ മായ്ച്ചു, ഈ പ്രക്രിയ പുറത്തുകടക്കും.

--സേവ്-ബിസി PATH
JavaScript അല്ലെങ്കിൽ HTML-ലേക്ക് കംപൈൽ ചെയ്യുമ്പോൾ, ഈ ഓപ്ഷൻ ബിറ്റ്കോഡിന്റെ ഒരു പകർപ്പ് സംരക്ഷിക്കും
നിർദ്ദിഷ്ട പാതയിലേക്ക്. ഉൾപ്പെടെ ലിങ്ക് ചെയ്‌തിരിക്കുന്ന എല്ലാ ഫയലുകളും ബിറ്റ്‌കോഡിൽ ഉൾപ്പെടും
സ്റ്റാൻഡേർഡ് ലൈബ്രറികൾ, കൂടാതെ ഏതെങ്കിലും ലിങ്ക്-ടൈം ഒപ്റ്റിമൈസേഷനുകൾക്ക് ശേഷം (എന്തെങ്കിലും ഉണ്ടെങ്കിൽ).

--memory-init-file
ഓണാണെങ്കിൽ, ഞങ്ങൾ ഒരു പ്രത്യേക മെമ്മറി ഇനീഷ്യലൈസേഷൻ ഫയൽ സൃഷ്ടിക്കുന്നു. ഇത് കൂടുതൽ കാര്യക്ഷമമാണ്
ജാവാസ്ക്രിപ്റ്റിനുള്ളിൽ ഉൾച്ചേർത്ത മെമ്മറി ഇനീഷ്യലൈസേഷൻ ഡാറ്റ ടെക്സ്റ്റായി സൂക്ഷിക്കുന്നതിനേക്കാൾ.
(ഡിഫോൾട്ട് ഓഫാണ്)

ടാർഗെറ്റ് ഫയൽ, വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ (-o ), എന്താണ് സൃഷ്ടിക്കപ്പെടേണ്ടതെന്ന് നിർവചിക്കുന്നു:

.js
ജാവാസ്ക്രിപ്റ്റ്

.html
ഉൾച്ചേർത്ത JavaScript ഉള്ള HTML

.ബിസി
LLVM ബിറ്റ്കോഡ് (സ്ഥിരസ്ഥിതി)

.ഒ
LLVM ബിറ്റ്കോഡ് (.bc പോലെ തന്നെ)

(എങ്കിൽ ശ്രദ്ധിക്കുക --memory-init-file ഉപയോഗിക്കുന്നു, തുടർന്ന് ഒരു .js അല്ലെങ്കിൽ .html ഫയലിന് പുറമേ
സൃഷ്ടിച്ചത്, ഒരു .mem ഫയലും ദൃശ്യമാകും.)

ദി -c ഓപ്ഷൻ (ലിങ്കർ പ്രവർത്തിപ്പിക്കരുതെന്ന് gcc യോട് പറയുന്നത്) LLVM ബിറ്റ്കോഡ് ആകാൻ കാരണമാകും
നിർമ്മിക്കുന്നത്, കെട്ടിടത്തിന്റെ അവസാന ലിങ്കിംഗ് ഘട്ടത്തിൽ മാത്രമേ emcc JavaScript സൃഷ്ടിക്കുകയുള്ളൂ.

ഇൻപുട്ട് ഫയൽ(കൾ) Clang-ന് കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന സോഴ്‌സ് കോഡ് ഫയലുകളാകാം (C അല്ലെങ്കിൽ C++), LLVM
ബൈനറി രൂപത്തിൽ ബിറ്റ്കോഡ്, അല്ലെങ്കിൽ മനുഷ്യർക്ക് വായിക്കാവുന്ന രൂപത്തിൽ LLVM അസംബ്ലി ഫയലുകൾ.

emccയെ നിരവധി പരിസ്ഥിതി വേരിയബിളുകൾ ബാധിക്കുന്നു. വിശദാംശങ്ങൾക്ക്, emcc-യുടെ ഉറവിടം കാണുക
('os.environ' എന്നതിനായി തിരയുക).

emcc: പിന്തുണയ്ക്കുന്ന ടാർഗെറ്റുകൾ: llvm ബിറ്റ്കോഡ്, ജാവാസ്ക്രിപ്റ്റ്, NOT elf (autoconf elf കാണാൻ ഇഷ്ടപ്പെടുന്നു
പങ്കിട്ട ഒബ്‌ജക്റ്റ് പിന്തുണ പ്രവർത്തനക്ഷമമാക്കുന്നതിന് മുകളിൽ)

പകർപ്പവകാശ

പകർപ്പവകാശം © 2013 the Emscripten authors (AUTHORS.txt കാണുക) ഇത് സൌജന്യവും തുറന്ന ഉറവിടവുമാണ്
MIT ലൈസൻസിന് കീഴിലുള്ള സോഫ്റ്റ്‌വെയർ. വാറന്റി ഇല്ല; കച്ചവടത്തിനോ അല്ലെങ്കിൽ
ഒരു പ്രത്യേക ഉദ്ദേശ്യത്തിനുള്ള ഫിറ്റ്നസ്.

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