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

പട്ടിക:

NAME

genparse - കമാൻഡ് ലൈൻ പാർസർ ജനറേറ്റർ

സിനോപ്സിസ്

genparse [ഓപ്ഷനുകൾ] ഫയലുകൾ...

വിവരണം

genparse ഒരു ജനറിക് കമാൻഡ് ലൈൻ പാർസർ ജനറേറ്ററാണ്. ലളിതവും സംക്ഷിപ്തവുമായതിൽ നിന്ന്
സ്പെസിഫിക്കേഷൻ ഫയലിൽ, നിങ്ങൾക്ക് കമാൻഡ് ലൈൻ പാരാമീറ്ററുകളും സ്വിച്ചുകളും നിർവചിക്കാം
നിങ്ങളുടെ പ്രോഗ്രാമിലേക്ക് കടന്നുപോകാൻ ആഗ്രഹിക്കുന്നു. യുടെ C, C++ അല്ലെങ്കിൽ Java കോഡ് Genparse സൃഷ്ടിക്കുന്നു
നിങ്ങൾക്കുള്ള പാഴ്സർ.

GNU എന്ന് Genparse അനുമാനിക്കുന്നു നീളമുള്ളത്(3) ഫംഗ്‌ഷൻ നിങ്ങളുടെ സി ലൈബ്രറിയിൽ നിർമ്മിച്ചിരിക്കുന്നു. വേണ്ടി
ജാവ നിങ്ങളുടെ ജാവ കമ്പൈലറിന് അനുയോജ്യമായ ഒരു ജാർ ഫയൽ വ്യക്തമാക്കേണ്ടി വന്നേക്കാം.

ഓപ്ഷനുകൾ

genparse ഈ ഓപ്ഷനുകൾ സ്വീകരിക്കുന്നു:

-c, --cppext വിപുലീകരണം
C++ ഫയൽ വിപുലീകരണം. (ഡിഫോൾട്ട് = cc)

-d ലോഗിംഗ് ഓണാക്കുക.

-f, --ലോഗ് ഫയൽ പേര്
ഫയലിന്റെ പേര് ലോഗ് ചെയ്യുക. (ഡിഫോൾട്ട് = genparse.log)

-h, --സഹായിക്കൂ
സഹായ വിവരങ്ങൾ പ്രദർശിപ്പിക്കുക.

-g, --ഗ്നുലിബ്
GNU Compatibility Library ഉപയോഗിക്കുക (Gnulib, കാണുക http://www.gnu.org/software/gnulib/).
സി ഔട്ട്പുട്ടിൽ മാത്രം ലഭ്യമാണ്. ചില തരങ്ങൾ കൂടി അനുവദിക്കുന്നു (ഒപ്പ് ചെയ്യാത്ത നീളം, intmax_t മുതലായവ)
ഇതിനായി Gnulib പരിവർത്തന പ്രവർത്തനങ്ങൾ നൽകുന്നു.

-i, --അന്താരാഷ്ട്രവൽക്കരിക്കുക
ടെക്സ്റ്റ് ഔട്ട്‌പുട്ടിന് ചുറ്റും ഇന്റർനാഷണലൈസേഷൻ മാക്രോ _() ഇടുക, അങ്ങനെ ജനറേറ്റഡ് പ്രോഗ്രാം
GNU gettext കമാൻഡ് ഉപയോഗിച്ച് അന്തർദേശീയമാക്കാം. നിലവിൽ നടപ്പാക്കുക മാത്രമാണ് ചെയ്യുന്നത്
സി ഔട്ട്പുട്ടിനായി.

-l, --ഭാഷ lang
ഔട്ട്പുട്ട് ഭാഷ. C, C++, Java എന്നിവ മാത്രമേ പിന്തുണയ്ക്കൂ. ഇനിപ്പറയുന്നവയിൽ ഏതെങ്കിലും
C++: "c++", "cpp", "cc", "cxx" എന്നിവ സൂചിപ്പിക്കുക. ജാവ ഉപയോഗത്തിന്: "java" അല്ലെങ്കിൽ "Java".
(ഡിഫോൾട്ട് = സി)

-o, --ഔട്ട്ഫിൽ പേര്
ഔട്ട്പുട്ട് ഫയലിന്റെ പേര്. (ഡിഫോൾട്ട് = parse_cl)

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

-o, --ഔട്ട്ഫിൽ ഫയലിന്റെ പേര്
ഔട്ട്പുട്ട് ഫയലിന്റെ റൂട്ട് നാമം. ഔട്ട്‌പുട്ട് ഭാഷ അനുസരിച്ചായിരിക്കും വിപുലീകരണം നിർണ്ണയിക്കുക
ഒരുപക്ഷേ മറ്റ് ഓപ്ഷനുകൾ വഴി. ഉദാഹരണത്തിന്, ഔട്ട്പുട്ട് ഭാഷ സി ആയിരിക്കുമ്പോൾ, നൽകുന്നു
ഈ ഓപ്‌ഷൻ "ഫയൽ" എന്നതിന്റെ ആർഗ്യുമെന്റ് "file.h" എന്നതിന്റെ ഔട്ട്‌പുട്ട് ഫയൽ നാമങ്ങൾക്ക് കാരണമാകും,
തലക്കെട്ട്, പാർസർ, കോൾബാക്ക് ഫയലുകൾ എന്നിവയ്ക്കായി യഥാക്രമം "file.c", "file_cb.c" എന്നിവ.
സ്ഥിര മൂല്യം "parse_cl" ആണ്.

-p, --പാർസെഫങ്ക് ഫങ്ക്
പാഴ്‌സിംഗ് ഫംഗ്‌ഷന്റെ പേര് / ക്ലാസ്സ്. ഈ ഓപ്ഷൻ ഉപയോക്താവിനെ പേര് വ്യക്തമാക്കാൻ അനുവദിക്കുന്നു
യഥാർത്ഥ കമാൻഡ് ചെയ്യുന്ന ഫംഗ്‌ഷന്റെ (സിക്ക്) അല്ലെങ്കിൽ ക്ലാസ് (സി++, ജാവ എന്നിവയ്‌ക്ക്).
ലൈൻ പാഴ്‌സിംഗ് (ഡിഫോൾട്ട് = "Cmdline").

-P, --നിരവധി പ്രിന്റുകൾ
ഓരോ കമാൻഡ് ലൈൻ പാരാമീറ്ററിനും ഒരു പ്രത്യേക പ്രിന്റ് കമാൻഡിൽ ഔട്ട്പുട്ട് സഹായ വാചകം.

-q, --നിശബ്ദമായി
നിശബ്‌ദ മോഡ് - സ്‌ക്രീൻ ഔട്ട്‌പുട്ട് ഇല്ല.

-s, --സ്റ്റാറ്റിക്-ഹെഡറുകൾ
ജനറേറ്റുചെയ്‌ത ഫയലുകളുടെ മുകളിലുള്ള വിവരണാത്മക തലക്കെട്ട് സ്ഥിരമായി നിലനിർത്തുക. ഇതില്ലാതെ
ഓപ്ഷൻ genparse പ്രിന്റുകൾ സൃഷ്ടിച്ച തീയതിയും സമയവും, Linux കേർണൽ പതിപ്പ്, കേർണൽ ബിൽഡ്
സമയം, കമ്പ്യൂട്ടർ ആർക്കിടെക്ചർ നാമം, ഹോസ്റ്റ് നാമം, ഉപയോക്തൃനാമം.

-v, --പതിപ്പ്
ഔട്ട്പുട്ട് പതിപ്പ്.

-D, --ഡയറക്‌ടറി
ഫലങ്ങൾ സംഭരിക്കുന്നതിനുള്ള ഡയറക്ടറി.

ഇൻപുട്ട് FILE

ഒരു genparse സ്പെസിഫിക്കേഷൻ ഫയൽ (സാധാരണയായി 'genparse ഫയൽ' എന്ന് വിളിക്കുന്നു) ഒരു സംഖ്യ ഉൾക്കൊള്ളുന്നു
എൻട്രികളുടെ, ഓരോ കമാൻഡ് ലൈൻ പാരാമീറ്ററിനും ഒന്ന്, ഫോമിന്റെ:

ഹ്രസ്വ_പേരുകൾ[*|!] [/ നീണ്ട_പേര്[*|!][=opt_name]] ടൈപ്പ് ചെയ്യുക [ ഓപ്ഷനുകൾ ]

A ഹ്രസ്വ_നാമം ഒരൊറ്റ പ്രതീകം (ചെറിയ അല്ലെങ്കിൽ മൂലധനം) അല്ലെങ്കിൽ ഒറ്റ അക്കമാണ്. നീണ്ട_പേര് ഒരു ആണ്
ദൈർഘ്യമേറിയ (കൂടുതൽ വിവരണാത്മക) ഓപ്ഷന്റെ പേര്. കമാൻഡ് ലൈനിൽ ഒരു ഹ്രസ്വ നാമം മുമ്പിലായിരിക്കും
ഒരൊറ്റ ഡാഷിലൂടെ (ഉദാ. '-എ') നീളമുള്ള പതിപ്പിന് മുമ്പ് രണ്ട് ഡാഷുകൾ (ഉദാ.
'--എല്ലാം'). ഒരു നീണ്ട പാരാമീറ്റർ പേര് ആവശ്യമില്ലെങ്കിൽ, നിങ്ങൾക്ക് ഹ്രസ്വമായത് മാത്രം വ്യക്തമാക്കാം
(കൂടാതെ സ്ലാഷ് ദൃശ്യമാകേണ്ടതില്ല). നീളം മാത്രമുള്ള ഒരു പരാമീറ്റർ വ്യക്തമാക്കുന്നതിന്
പേര് സെറ്റ് ഹ്രസ്വ_പേരുകൾ ലേക്ക് ഒന്നുമില്ല. ഒന്നിലധികം ഹ്രസ്വ ഓപ്ഷനുകൾ സാധ്യമാണ്, അതിനാൽ
ഉദാഹരണ ക്രമീകരണം ഹ്രസ്വ_നാമം 'aA' ലേക്ക് ഒപ്പം നീണ്ട_പേര് 'എല്ലാം' എന്നത് വ്യക്തമാക്കാൻ അനുവദിക്കും
കമാൻഡ് ലൈൻ '-a' അല്ലെങ്കിൽ '-A' അല്ലെങ്കിൽ '--all' ആയി മാറുക, അവയെല്ലാം ഒരേ കാര്യം ചെയ്യുന്നു.

A * ശേഷം ഹ്രസ്വ_നാമം or നീണ്ട_പേര് വാദം ഐച്ഛികമാക്കുന്നു. ഇതിനായി ഇത് വ്യക്തമാക്കാം
ഹ്രസ്വവും നീണ്ടതുമായ ഓപ്ഷനുകൾ വെവ്വേറെ.

A ! ശേഷം ഹ്രസ്വ_നാമം or നീണ്ട_പേര് ഓപ്ഷൻ ബൂളിയൻ ആക്കുന്നു. ഇത് ഒന്നിനെ സംയോജിപ്പിക്കാൻ അനുവദിക്കുന്നു
ഒരു ഓപ്‌ഷണൽ അല്ലെങ്കിൽ നിർബന്ധിത ആർഗ്യുമെന്റുള്ള ഒരു നീണ്ട ഓപ്‌ഷനോടുകൂടിയ boolean ഷോർട്ട് ഓപ്ഷൻ അല്ലെങ്കിൽ to
ഒരു ബൂലിയൻ ലോംഗ് ഓപ്‌ഷനും ഒരു ഓപ്‌ഷണൽ അല്ലെങ്കിൽ നിർബന്ധിത ആർഗ്യുമെന്റുമായി ഒരു ഹ്രസ്വ ഓപ്ഷനും സംയോജിപ്പിക്കുക.
A ! ഓപ്ഷന്റെ തരം ആണെങ്കിൽ അർത്ഥമില്ല പതാക.

ടൈപ്പ് ചെയ്യുക അതിലൊന്നായിരിക്കണം int ഫ്ലോട്ട് പ്രതീകം സ്ട്രിംഗ് or പതാക. ആദ്യത്തെ നാലെണ്ണം സ്വയം ആയിരിക്കണം.
വിശദീകരണം. അവസാനത്തേത് ആർഗ്യുമെന്റുകളൊന്നും എടുക്കാത്ത ഒരു "സ്വിച്ച്" ഓപ്ഷനാണ്. സി ഔട്ട്പുട്ടിനും എങ്കിൽ
--gnulib കമാൻഡ് ലൈനിൽ സജ്ജീകരിച്ചിരിക്കുന്നു കൂടാതെ ഇനിപ്പറയുന്ന തരങ്ങളും അനുവദനീയമാണ്: നീളമുള്ള
(ദീർഘമായ സംഖ്യയ്ക്കായി), നീളം (ഒപ്പ് ചെയ്യാത്ത നീണ്ട സംഖ്യയ്ക്ക്) intmax (intmax_t-ന്, Gnulib-ൽ നിർവചിച്ചിരിക്കുന്നത്)
uintmax (uintmax_t-ന്), ഇരട്ട.

ഇനിപ്പറയുന്നവ ഓപ്ഷനുകൾ പിന്തുണയ്ക്കുന്നു. അവ ഏത് ക്രമത്തിലും ദൃശ്യമാകാം
വിവരണങ്ങൾ ഓരോ ഫീൽഡിലും ഒരെണ്ണം മാത്രമേ ഓരോ ഓപ്ഷനും നിർവചിക്കാവൂ.

A സ്ഥിരസ്ഥിതി മൂല്യം പരാമീറ്ററിനായി. ഒരു സ്‌ട്രിങ്ങിന് ഇത് പ്ലെയിൻ ഡിഫോൾട്ട് മാത്രമാണ്
മൂല്യം, അത് എന്തായാലും. സ്ട്രിംഗുകൾക്ക്, ബ്രേസുകൾക്കുള്ളിൽ ഒരു ഡിഫോൾട്ട് വ്യക്തമാക്കിയിരിക്കണം
ഉദ്ധരണികൾ, കൂടാതെ വൈറ്റ്‌സ്‌പെയ്‌സ് ഉൾപ്പെട്ടേക്കാം, ഉദാ {"എന്റെ സ്ഥിര മൂല്യം"}. ഒരു ചാരിന്
പരാമീറ്റർ അത് ഒറ്റ ഉദ്ധരണികളിൽ ഉൾപ്പെടുത്തിയിരിക്കണം, ഉദാ 'a' അല്ലെങ്കിൽ '\n'.

A ശ്രേണി ബ്രാക്കറ്റിനുള്ളിലെ മൂല്യങ്ങളുടെ. താഴ്ന്നതും ഉയർന്നതുമായ മൂല്യങ്ങൾ a യ്ക്കിടയിൽ വ്യക്തമാക്കിയിരിക്കുന്നു
ശ്രേണി സ്പെസിഫയർ (ഒന്നുകിൽ '...' അല്ലെങ്കിൽ '..'). ഒന്നുകിൽ ഉയർന്നതോ താഴ്ന്നതോ ആകാം
ഒരു വശത്ത് മാത്രം പരിമിതപ്പെടുത്തിയിരിക്കുന്ന പരിധിക്ക് ഒഴിവാക്കി. പരാമീറ്റർ പരിശോധിക്കും
ഇത് ഈ പരിധിക്കുള്ളിലാണെന്ന് ഉറപ്പാക്കുക.

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

A വിവരണം ഇരട്ട ഉദ്ധരണികളിൽ. ഇത് അച്ചടിക്കുന്നത് ഉപയോഗം() പ്രവർത്തനം. ഒന്നാണെങ്കിൽ
വരി പര്യാപ്തമല്ല, തുടർന്ന് ഒന്നിലധികം വിവരണങ്ങൾ വ്യക്തമാക്കുക, ഓരോ വരിയിലും ഓരോന്നും
അവ ഇരട്ട ഉദ്ധരണികളിൽ. Genparse ലെ 1st കോളത്തിൽ വിവരണം ആരംഭിക്കുകയാണെങ്കിൽ
ഫയലിൽ അത് ഒന്നാം നിരയിലും പ്രിന്റ് ചെയ്യപ്പെടും ഉപയോഗം() പ്രവർത്തനം.

A #gp_ഉൾപ്പെടുന്നു മറ്റൊരു genparse ഫയൽ ഉൾപ്പെടുത്താൻ നിർദ്ദേശം genparse-നോട് നിർദ്ദേശിക്കും,
ഉദാ #gp_ഉൾപ്പെടുന്നു മറ്റൊന്ന്.ജി.പി. ഉൾപ്പെടുത്തിയതിൽ പാരാമീറ്റർ നിർവചനങ്ങൾ മാത്രമേ അനുവദിക്കൂ
ഫയൽ, ആഗോള നിർദ്ദേശങ്ങളൊന്നുമില്ല.

An __ERR_MSG__(err_txt) നിർദ്ദേശം. അച്ചടിച്ച പിശക് സന്ദേശം വ്യക്തമാക്കുന്നു
വാദം പരിവർത്തനം ചെയ്യാൻ കഴിയാത്തപ്പോൾ. ഉദാഹരണം: __ERR_MSG__("%s: അസാധുവായ
വാദം"). ഒന്നുകിൽ കൺവേർഷൻ ഫംഗ്‌ഷൻ ആയിരിക്കുമ്പോൾ ഈ സന്ദേശം പ്രിന്റ് ചെയ്യപ്പെടും
പരാജയപ്പെട്ടു അല്ലെങ്കിൽ വാദം പരിധിക്ക് പുറത്തായപ്പോൾ. ഒരെണ്ണം അടങ്ങിയിരിക്കുന്നതായി കരുതുന്നു %s അത് ചെയ്യും
പരിവർത്തനം ചെയ്യാൻ കഴിയാത്ത അഗ്രൂമെന്റ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക. എപ്പോൾ മാത്രമേ ലഭ്യമാകൂ
Genparse ഉപയോഗിച്ച് വിളിക്കപ്പെടുന്നു --ഗ്നുലിബ്, മറ്റുവിധത്തിൽ അവഗണിച്ചു.

ഓപ്ഷണലായി ഒരു കൺവേർഷൻ ഫംഗ്ഷൻ രണ്ടാമത്തെ ആർഗ്യുമെന്റായി ചേർക്കാം, ഉദാ
__ERR_MSG__("%s: അസാധുവായ വാദം", ഉദ്ധരണി). ഇത് ഒരു പിശക് സന്ദേശത്തിലേക്ക് നയിക്കും
പോലെ പിശക് (EXIT_FAILURE, 0, "%s: അസാധുവായ വാദം", quotearg (ഓപ്റ്റിൻഡ്)).

An __ADD_FLAG__ നിർദ്ദേശം. കമാൻഡ് ലൈൻ പാരാമീറ്റർ ഇല്ലെങ്കിൽ മാത്രം അർത്ഥമാക്കുന്നു
ഇതിനകം ഒരു ഫ്ലാഗ്, ഈ സാഹചര്യത്തിൽ ഒരു അധിക ഫ്ലാഗ് പാരാമീറ്റർ ചേർത്തിരിക്കുന്നു
കമാൻഡ് ലൈനിൽ കമാൻഡ് ലൈൻ പാരാമീറ്റർ വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ സജ്ജമാക്കുക. ഈ ഓപ്ഷൻ
ഒരു പാരാമീറ്ററിന് ഒരു ഓപ്ഷണൽ ആർഗ്യുമെന്റ് ഉണ്ടെങ്കിൽ അത് സ്വയമേവ സജ്ജീകരിക്കുന്നു.

A __CODE__(പ്രസ്താവനകൾ) നിർദ്ദേശം. നിർദ്ദിഷ്ട കോഡ് പ്രസ്താവനകൾ പകർത്തി
അക്ഷരാർത്ഥത്തിൽ. ഉദാഹരണം: __CODE__(printf ("പാരാമീറ്റർ x ആയിരുന്നു സെറ്റ്");). നിർദ്ദിഷ്ട കോഡ്
ഒന്നിൽ കൂടുതൽ വരിയിൽ നീട്ടാൻ കഴിയും. ജെൻപാർസിന് അവസരം നൽകുന്നതിന്
കോഡ് ശരിയായി ഇൻഡന്റ് ചെയ്യുക, സ്പേസും ടാബ് ഇൻഡന്റേഷനുകളും ഒന്നിൽ മിക്സ് ചെയ്യരുത് __കോഡ്__
പ്രസ്താവന.

A __STORE_LONGINDEX__ നിർദ്ദേശം. ഒരു ഇന്ററർ ടൈപ്പ് ഫീൽഡ് ചേർക്കാൻ Genparse-നോട് നിർദ്ദേശിക്കുന്നു
ലോങ്‌ഇൻഡക്സ് വേരിയബിളിലേക്ക് സജ്ജീകരിക്കുന്ന ഫല ക്ലാസിലേക്ക് (അവസാന ആർഗ്യുമെന്റ് ഇൻ
@code{getopt_long()}) എന്നതിലേക്കുള്ള കോൾ. ഈ പുതിയ ഫീൽഡിന് അതേ പേര് ലഭിക്കും
റിസൾട്ട് ഫീൽഡ് ഇത് ഒരു മായി ബന്ധപ്പെട്ടതാണ് _ലി പോസ്റ്റ്ഫിക്സ്.

ഇനിപ്പറയുന്നവ ഗ്ലോബൽ നിർദ്ദേശങ്ങൾ പിന്തുണയ്ക്കുന്നു. അവ ഏത് ക്രമത്തിലും പ്രത്യക്ഷപ്പെടാം.

An # ഉൾപ്പെടുത്തുക പ്രസ്തുത ഉൾപ്പെടുത്തിയ പ്രസ്താവന പകർത്താൻ നിർദ്ദേശം genparse-ൽ നിർദ്ദേശിക്കും
genparse സൃഷ്ടിച്ച C അല്ലെങ്കിൽ C++ കോഡിലേക്ക്, എന്നാൽ ഏതെങ്കിലും ഹെഡർ ഫയലുകളോ കോൾബാക്കോ അല്ല
ഫയലുകൾ.

A #നിർബന്ധം നിർദ്ദേശം ഉപയോഗിക്കാം, ഇത് ഉപയോഗം() ഫംഗ്‌ഷൻ കോളുകൾ മനോഹരമാക്കുന്നു. അത് അനുവദിക്കുന്നു
സ്വിച്ചുകൾ പിന്തുടരുന്ന നിർബന്ധിത കമാൻഡ് ലൈൻ പാരാമീറ്ററുകൾ നിങ്ങൾ വ്യക്തമാക്കണം. കുറിപ്പ്
നിർബന്ധിത പാരാമീറ്ററുകൾക്കായി Genparse പരിശോധിക്കുന്നില്ല, അവ പ്രിന്റ് ചെയ്‌തിരിക്കുന്നു
ഉപയോഗം () കൂടെ പ്രവർത്തനം __നിർബന്ധങ്ങൾ__ നിർദ്ദേശം. ഒഴിവാക്കി: ചേർക്കുക നിർബന്ധമാണ്
പാരാമീറ്ററുകൾ in The #ഉപയോഗം വിഭാഗം പകരം.

An # എക്സിറ്റ്_മൂല്യം ഒരു പിശക് സംഭവിച്ചാൽ എക്സിറ്റ് മൂല്യം വ്യക്തമാക്കുന്ന നിർദ്ദേശം.
സ്ഥിരസ്ഥിതി EXIT_FAILURE ആണ്.

A #ബ്രേക്ക്_ലൈനുകൾ ഏത് ലൈനുകളാണ് തകർക്കേണ്ടതെന്ന് വ്യക്തമാക്കുന്ന നിർദ്ദേശം
സഹായ സ്ക്രീനിൽ. അല്ലെങ്കിൽ #ബ്രേക്ക്_ലൈനുകൾ നിർദ്ദേശം വ്യക്തമാക്കിയ ശേഷം വരികൾ ആയിരിക്കും
genparse ഫയലിൽ നൽകിയിരിക്കുന്നത് പോലെ കൃത്യമായി പ്രിന്റ് ചെയ്തു.

If #ഇല്ല_ഘടന വ്യക്തമാക്കിയാൽ, അതിൽ നിറയുന്ന ഒരു ഘടനയും നിർവചിക്കില്ല
ജനറേറ്റ് ചെയ്ത പാർസറിലെ കമാൻഡ് ലൈൻ പാരാമീറ്ററുകൾ. നിങ്ങളാണെങ്കിൽ ഇത് ഉപയോഗപ്രദമാകും
നിങ്ങളുടെ സ്വന്തം കോഡ് ചേർക്കാൻ ആഗ്രഹിക്കുന്നു __കോഡ്__ പകരം പ്രസ്താവനകൾ. സിയെ മാത്രമാണ് പിന്തുണച്ചത്
.ട്ട്‌പുട്ട്.

A #കയറ്റുമതി_നീണ്ട_ഓപ്‌ഷനുകൾ നിർദ്ദേശം. എങ്കിൽ #കയറ്റുമതി_നീണ്ട_ഓപ്‌ഷനുകൾ പിന്നീട് നിർവചിച്ചിരിക്കുന്നത് a
ഫംഗ്ഷൻ #നീണ്ട_ഓപ്ഷനുകൾ () ഉപയോഗിക്കുന്ന ലോംഗ് ഓപ്‌ഷൻ അറേ കയറ്റുമതി ചെയ്യുന്ന ചേർക്കുന്നു
#Getopt_long(). ഈ നിർദ്ദേശം മറ്റ് ഭാഷകളിൽ സി ഔട്ട്‌പുട്ടിന് മാത്രമേ ലഭ്യമാകൂ
അത് അവഗണിക്കപ്പെടുന്നു.

A ഗ്ലോബൽ തിരിച്ചു വിളിക്കുക ഫംഗ്ഷൻ. പരസ്പരാശ്രിതത്വം പരിശോധിക്കുന്നതിന് ഈ പ്രവർത്തനം ഉപയോഗപ്രദമാണ്
പരാമീറ്ററുകൾക്കിടയിൽ. ഓരോ വ്യക്തിയിലും പരസ്പരാശ്രിതത്വം പരിശോധിക്കാനാവില്ല
കോൾബാക്ക് ഫംഗ്‌ഷൻ കാരണം ഈ ഫംഗ്‌ഷനുകളെ വിളിക്കുന്ന ക്രമം വ്യത്യാസപ്പെടുന്നു,
കമാൻഡ് ലൈനിലെ പാരാമീറ്ററുകളുടെ ക്രമം അനുസരിച്ച്.

Genparse-ഉം സൃഷ്ടിക്കുന്നു a ഉപയോഗം() ഒരു സഹായ വാചകം പ്രിന്റ് ചെയ്യുന്ന ഫംഗ്ഷൻ
Genparse പാഴ്‌സർ ജനറേറ്റ് ചെയ്യുന്ന പ്രോഗ്രാമിന്റെ ഉപയോഗം. ഇത് ഇഷ്‌ടാനുസൃതമാക്കാവുന്നതാണ്
Genparse ഫയലിന്റെ ചുവടെ ഒരു ഉപയോഗ വിഭാഗം വ്യക്തമാക്കുന്നു. അങ്ങനെയൊരു വിഭാഗം ഇല്ലെങ്കിൽ
ഇത് സ്ഥിരസ്ഥിതിയായി വ്യക്തമാക്കിയിരിക്കുന്നു

#ഉപയോഗം_ആരംഭിക്കുക
ഉപയോഗം: __PROGRAM_NAME__ __OPTIONS_SHORT__ __MANDATORIES__
__ഗ്ലോസറി__
#ഉപയോഗം_അവസാനം

ഉപയോഗ വിഭാഗം ആരംഭിക്കുന്നു #ഉപയോഗം_ആരംഭിക്കുക കൂടെ അവസാനിക്കുന്നു #ഉപയോഗം_അവസാനം. തമ്മിലുള്ള ഏത് വാചകവും
ഇനിപ്പറയുന്ന കീവേഡുകൾ ഒഴികെ അച്ചടിച്ച പദാനുപദം, ലിസ്‌റ്റ് ചെയ്‌തതുപോലെ മാറ്റിസ്ഥാപിക്കും
താഴെ:

__PROGRAM_NAME__: പ്രോഗ്രാമിന്റെ പേര്. C, C++ എന്നിവയിൽ പ്രോഗ്രാമിന്റെ പേര് നൽകിയിരിക്കുന്നു
argv[0].

__OPTIONS_SHORT__: ലഭ്യമായ ഷോർട്ട് ഫോം ഓപ്ഷനുകളുടെ ഒരു ലിസ്റ്റ്, ഉദാ [ -abc ].

__നിർബന്ധങ്ങൾ__: #mandatory ഉപയോഗിച്ച് നിർവചിച്ചിരിക്കുന്ന എല്ലാ നിർബന്ധിത പാരാമീറ്ററുകളുടെയും ഒരു ലിസ്റ്റ്
കമാൻഡുകൾ. ഒഴിവാക്കി: പട്ടിക നിർബന്ധമാണ് പാരാമീറ്ററുകൾ ഇവിടെ നേരിട്ട്.

__ഗ്ലോസറി__: എല്ലാ കമാൻഡ് ലൈൻ ഓപ്ഷനുകളുടെയും ഒരു വിവരണം. ഇതാണ് വിവരം
മാനുഷികമായി വായിക്കാവുന്ന രൂപത്തിലുള്ള പാരാമീറ്റർ നിർവചനങ്ങൾക്കായി നൽകിയിരിക്കുന്നു. അതിൽ ഉൾപ്പെടുന്നു
പാരാമീറ്റർ തരം, ഡിഫോൾട്ട്, റേഞ്ച്, ഏതെങ്കിലും അഭിപ്രായങ്ങൾ. അടങ്ങുന്ന ഒരു വരി
__ഗ്ലോസറി__ പാരാമീറ്ററുകളുടെ ഗ്ലോസറി ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു, ലെ മറ്റേതെങ്കിലും വാചകം
അതേ വരി അവഗണിക്കപ്പെട്ടു.

__GLOSSARY_GNU__: അതുപോലെ __ഗ്ലോസറി__ എന്നാൽ ഗ്നു ശൈലിയിൽ. ഓപ്ഷണലായി ഒരു പിന്തുടരുന്നു
വിവരണാത്മക വാചകത്തിന്റെ ഇൻഡന്റേഷൻ വ്യക്തമാക്കുന്ന ബ്രാക്കറ്റുകളിലെ പൂർണ്ണസംഖ്യ (ഉദാ
__ഗ്ലോസറി__(30)). ഡിഫോൾട്ട് ഇൻഡന്റേഷൻ 24 ആണ്.

__STRING__(കൾ): ഒരു സ്ട്രിംഗ് സ്ഥിരാങ്കം, സിയിൽ ഒരുപക്ഷേ ഒരു സ്ട്രിംഗ് മാക്രോ നിർവചിച്ചിരിക്കുന്നു
#പ്രീപ്രൊസസ്സർ കമാൻഡ് നിർവചിക്കുക. ഈ മാക്രോ മറ്റൊരു ഫയലിൽ നിന്ന് ഇറക്കുമതി ചെയ്യാൻ കഴിയും
genparse ഫയലിൽ നിർദ്ദേശങ്ങൾ ഉൾപ്പെടുത്തുക. ജാവ ഔട്ട്പുട്ട് സൃഷ്ടിക്കുമ്പോൾ അവഗണിക്കപ്പെട്ടു.

__INT__(x): ഒരു പൂർണ്ണസംഖ്യ സ്ഥിരാങ്കം, C യിൽ ഒരുപക്ഷേ നിർവചിച്ചിരിക്കുന്ന ഒരു പൂർണ്ണസംഖ്യ മാക്രോ
#പ്രീപ്രൊസസ്സർ കമാൻഡ് നിർവചിക്കുക. ഈ മാക്രോ മറ്റൊരു ഫയലിൽ നിന്ന് ഇറക്കുമതി ചെയ്യാൻ കഴിയും
genparse ഫയലിൽ നിർദ്ദേശങ്ങൾ ഉൾപ്പെടുത്തുക. ജാവ ഔട്ട്പുട്ട് സൃഷ്ടിക്കുമ്പോൾ അവഗണിക്കപ്പെട്ടു.

__CODE__(പ്രസ്താവനകൾ): പരാമീറ്റർ ഓപ്ഷനുകൾ പോലെ തന്നെ, മുകളിൽ കാണുക.

__DO_NOT_DOCUMENT__: ഈ മാക്രോ അടങ്ങുന്ന ഒരു വരിയും പ്രിന്റ് ചെയ്യില്ല
ഉപയോഗം() പ്രവർത്തനം. ഇല്ലാതെ കമാൻഡ് ലൈൻ പാരാമീറ്ററുകൾ നടപ്പിലാക്കാൻ ഉപയോഗിക്കാം
സഹായ സ്ക്രീനിൽ അവ ലിസ്റ്റ് ചെയ്യുന്നു.

__NL__: പുതിയ വര. ഓട്ടോമാറ്റിക് ലൈൻ ബ്രേക്കിംഗ് സമയത്ത് ലൈനുകൾ സ്വമേധയാ തകർക്കാൻ ഉപയോഗപ്രദമാണ്
ഓണാണ് (കാണുക #ബ്രേക്ക്_ലൈനുകൾ). ജാവ ഔട്ട്പുട്ട് സൃഷ്ടിക്കുമ്പോൾ അവഗണിക്കപ്പെട്ടു.

__NEW_PRINT__: സജീവ പ്രിന്റ് കമാൻഡ് അടച്ച് പുതിയൊരെണ്ണം ആരംഭിക്കുക.

__COMMENT__(വാചകം): ഉപയോഗ വാചകം അച്ചടിക്കുന്നതിനുള്ള കോഡിൽ കമന്റ് ചെയ്യുക.

ദൈർഘ്യമേറിയ ഓപ്ഷനുകൾക്ക് ശേഷം ഒരു = ചിഹ്നവും ഒരു ഓപ്ഷണൽ പദവിയും നൽകാം opt_name അത് സാധിക്കും
ഇനിപ്പറയുന്ന വിവരണത്തിൽ പരാമർശിക്കാം. ൽ ഇത് ഉപയോഗിക്കും ഉപയോഗം() ഫംഗ്ഷൻ
മാത്രം. ഉദാഹരണത്തിന് ഇനിപ്പറയുന്ന genparse ലൈൻ

s / block-size=SIZE int "SIZE-byte blocks ഉപയോഗിക്കുക"

സഹായ സ്ക്രീനിൽ ഇനിപ്പറയുന്ന വരിയിലേക്ക് നയിക്കും

[-s ] [ --block-size=SIZE ] (തരം=INTEGER)
SIZE-ബൈറ്റ് ബ്ലോക്കുകൾ ഉപയോഗിക്കുക

genparse ശൈലിയിൽ (__ഗ്ലോസറി__) അഥവാ

-s, --block-size=SIZE SIZE-ബൈറ്റ് ബ്ലോക്കുകൾ ഉപയോഗിക്കുന്നു

ഗ്നു ശൈലിയിൽ (__GLOSSARY_GNU__).

സൂചിപ്പിക്കാൻ ഓപ്ഷണൽ പേരിന് ചുറ്റും ചതുര ബ്രേസുകൾ ഇടാനും സാധിക്കും
വാദം ഐച്ഛികമാണെന്ന്. എന്നിരുന്നാലും ജനറേറ്റ് ചെയ്‌ത പാഴ്‌സറിന് ഇതിന് അർത്ഥമില്ല. ഉപയോഗിക്കുക
* ഒരു വാദം ഓപ്ഷണൽ ആക്കുന്നതിന് പോസ്റ്റ്ഫിക്സുകൾ.

s* / block*[=SIZE] int "ബ്ലോക്കുകൾ ഉപയോഗിക്കുക."
"SIZE നൽകിയില്ലെങ്കിൽ അവർക്ക് 1kB വലുപ്പം ലഭിക്കും."

സഹായ സ്ക്രീനിൽ ഇനിപ്പറയുന്ന വരിയിലേക്ക് നയിക്കും

-s, --ബ്ലോക്ക്[=SIZE] ബ്ലോക്കുകൾ ഉപയോഗിക്കുന്നു.
SIZE നൽകിയില്ലെങ്കിൽ അവർക്ക് 1kB വലുപ്പം ലഭിക്കും.

ഉദാഹരണം

ഒരു സാമ്പിൾ genparse ഫയൽ ഇതാ:

#ഉൾപ്പെടുന്നു

/* അഭിപ്രായം */
my_callback()

i / ആവർത്തനങ്ങൾ int 100 [10...1000] iter_callback()
"നടത്തേണ്ട ആവർത്തനങ്ങളുടെ എണ്ണം."

/*
* അഭിപ്രായം
*/

n / നെയിം സ്ട്രിംഗ് {"mike"} name_cb() "User's name"
s / str സ്ട്രിംഗ് "ടെസ്റ്റ് സ്ട്രിംഗ്"
f പതാക "ഒരു മണ്ടൻ പതാക!"

#ഉപയോഗം_ആരംഭിക്കുക
ഉപയോഗം: __PROGRAM_NAME__ __OPTIONS_SHORT__ ഫയലിന്റെ പേര്
ഇതൊരു മണ്ടൻ പരീക്ഷണ പരിപാടി മാത്രമാണ്.
__ഗ്ലോസറി__
#ഉപയോഗം_അവസാനം

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