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

പട്ടിക:

NAME

കുറ്റി, ലെഗ് - പാഴ്സർ ജനറേറ്ററുകൾ

സിനോപ്സിസ്

പെഗ് [-hvV -ഔട്ട്പുട്ട്] [ഫയലിന്റെ പേര് ...]
കാല് [-hvV -ഔട്ട്പുട്ട്] [ഫയലിന്റെ പേര് ...]

വിവരണം

പെഗ് ഒപ്പം കാല് റിക്കേഴ്‌സീവ്-ഡിസെന്റ് പാഴ്‌സറുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള ഉപകരണങ്ങളാണ്: പ്രകടനം നടത്തുന്ന പ്രോഗ്രാമുകൾ
ടെക്സ്റ്റിൽ പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ. അവർ ഒരു പാഴ്സിംഗ് എക്സ്പ്രഷൻ വ്യാകരണം (PEG) [ഫോർഡ് 2004] ലേക്ക് പ്രോസസ്സ് ചെയ്യുന്നു
ആ വ്യാകരണത്തിന്റെ നിയമപരമായ വാക്യങ്ങൾ തിരിച്ചറിയുന്ന ഒരു പ്രോഗ്രാം നിർമ്മിക്കുക. പെഗ് PEG-കൾ പ്രോസസ്സ് ചെയ്യുന്നു
ഫോർഡ് വിവരിച്ച യഥാർത്ഥ വാക്യഘടന ഉപയോഗിച്ച് എഴുതിയത്; കാല് ഉപയോഗിച്ച് എഴുതിയ PEG-കൾ പ്രോസസ്സ് ചെയ്യുന്നു
അൽപ്പം വ്യത്യസ്തമായ വാക്യഘടനയും കൺവെൻഷനുകളും അതിനെ ആകർഷകമാക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്
ഉപയോഗിച്ച് നിർമ്മിച്ച പാർസറുകൾക്ക് പകരം വയ്ക്കൽ Lex(1) ഉം yac(1). വ്യത്യസ്തമായി Lex ഒപ്പം yac, പെഗ് ഒപ്പം കാല്
അൺലിമിറ്റഡ് ബാക്ക്‌ട്രാക്കിംഗിനെ പിന്തുണയ്ക്കുക, അവ്യക്തമാക്കാനുള്ള മാർഗമായി ഓർഡർ ചോയ്സ് നൽകുക, കൂടാതെ
സ്കാനിംഗും (ലെക്സിക്കൽ അനാലിസിസ്) പാഴ്സിംഗും (സിന്റക്റ്റിക് അനാലിസിസ്) ഒന്നായി സംയോജിപ്പിക്കാൻ കഴിയും
പ്രവർത്തനം.

പെഗ് വ്യക്തമാക്കിയത് വായിക്കുന്നു ഫയലിന്റെ പേര്s, അല്ലെങ്കിൽ ഇല്ലെങ്കിൽ സാധാരണ ഇൻപുട്ട് ഫയലിന്റെ പേര്കൾ നൽകിയിരിക്കുന്നു, a
ജനറേറ്റുചെയ്യാനുള്ള പാഴ്‌സറിനെ വിവരിക്കുന്ന വ്യാകരണം. പെഗ് തുടർന്ന് ഒരു സി സോഴ്സ് ഫയൽ ജനറേറ്റ് ചെയ്യുന്നു
ഒരു ഫംഗ്ഷൻ നിർവചിക്കുന്നു yyparse(). ഈ സി സോഴ്സ് ഫയൽ ഉൾപ്പെടുത്താം അല്ലെങ്കിൽ കംപൈൽ ചെയ്യാം
ഒരു ക്ലയന്റ് പ്രോഗ്രാമുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു. ഓരോ തവണയും ക്ലയന്റ് പ്രോഗ്രാം വിളിക്കുന്നു yyparse() പാഴ്സർ
പാഴ്‌സിംഗ് നിയമങ്ങൾക്കനുസൃതമായി ഇൻപുട്ട് ടെക്‌സ്‌റ്റ് ഉപയോഗിക്കുന്നു, ലെ ആദ്യ നിയമത്തിൽ നിന്ന് ആരംഭിക്കുന്നു
വ്യാകരണം. yyparse() പ്രകാരം ഇൻപുട്ട് പാഴ്‌സ് ചെയ്യാൻ കഴിയുമെങ്കിൽ പൂജ്യമല്ലാത്തത് നൽകുന്നു
വ്യാകരണം; ഇൻപുട്ട് പാഴ്‌സ് ചെയ്യാൻ കഴിയുന്നില്ലെങ്കിൽ അത് പൂജ്യം നൽകുന്നു.

ജനറേറ്റുചെയ്‌തതിൽ ബാഹ്യമായി ദൃശ്യമാകുന്ന എല്ലാ ചിഹ്നങ്ങൾക്കും 'yy' അല്ലെങ്കിൽ 'YY' എന്ന പ്രിഫിക്‌സ് മുൻകൂട്ടി നിശ്ചയിച്ചിരിക്കുന്നു
പാഴ്സർ. ക്ലയന്റ് പ്രോഗ്രാമുകളിലെ നെയിംസ്പേസ് മലിനീകരണത്തിന്റെ അപകടസാധ്യത കുറയ്ക്കുന്നതിനാണ് ഇത് ഉദ്ദേശിക്കുന്നത്.
('yy' എന്നതിന്റെ തിരഞ്ഞെടുപ്പ് ചരിത്രപരമാണ്; കാണുക Lex(1) ഉം yac(1), ഉദാഹരണത്തിന്.)

ഓപ്ഷനുകൾ

പെഗ് ഒപ്പം കാല് ഇനിപ്പറയുന്ന ഓപ്ഷനുകൾ നൽകുക:

-h ലഭ്യമായ ഓപ്ഷനുകളുടെ ഒരു സംഗ്രഹം പ്രിന്റ് ചെയ്യുകയും തുടർന്ന് പുറത്തുകടക്കുകയും ചെയ്യുന്നു.

-ഔട്ട്പുട്ട്
സൃഷ്ടിച്ച പാഴ്സർ ഫയലിലേക്ക് എഴുതുന്നു ഔട്ട്പുട്ട് സാധാരണ ഔട്ട്പുട്ടിന് പകരം.

-v ജോലി ചെയ്യുമ്പോൾ സാധാരണ പിശകിലേക്ക് വാചാലമായ വിവരങ്ങൾ എഴുതുന്നു.

-V സ്റ്റാൻഡേർഡ് പിശകിലേക്ക് പതിപ്പ് വിവരങ്ങൾ എഴുതുന്നു, തുടർന്ന് പുറത്തുകടക്കുന്നു.

A SIMPLE ഉദാഹരണം

ഇനിപ്പറയുന്നവ പെഗ് ഇൻപുട്ട് ഒരൊറ്റ നിയമം ('ആരംഭിക്കുക' എന്ന് വിളിക്കുന്നു) ഉള്ള ഒരു വ്യാകരണം വ്യക്തമാക്കുന്നു, അതായത്
ഇൻപുട്ടിൽ "ഉപയോക്തൃനാമം" എന്ന സ്ട്രിംഗ് അടങ്ങിയിരിക്കുമ്പോൾ സംതൃപ്തി.

ആരംഭിക്കുക <- "ഉപയോക്തൃനാമം"

(ഉദ്ധരണ ചിഹ്നങ്ങൾ അല്ല പൊരുത്തപ്പെടുന്ന വാചകത്തിന്റെ ഭാഗം; അവ അക്ഷരാർത്ഥത്തിൽ സൂചിപ്പിക്കാൻ സഹായിക്കുന്നു
പൊരുത്തപ്പെടുത്താനുള്ള സ്ട്രിംഗ്.) മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, yyparse() ജനറേറ്റ് ചെയ്‌ത സി ഉറവിടത്തിൽ തിരികെ വരും
ഇൻപുട്ടിൽ നിന്ന് വായിക്കുന്ന അടുത്ത എട്ട് പ്രതീകങ്ങൾ "ഉപയോക്തൃനാമം" എന്ന് എഴുതിയാൽ മാത്രം പൂജ്യമല്ല.
ഇൻപുട്ടിൽ മറ്റെന്തെങ്കിലും അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, yyparse() പൂജ്യം നൽകുന്നു, ഇൻപുട്ടൊന്നും ഉണ്ടാകില്ല
ദഹിപ്പിച്ചു. (പിന്നീടുള്ള കോളുകൾ yyparseപാഴ്സർ ആയതിനാൽ () പൂജ്യവും നൽകും
"ഉപയോക്തൃനാമം" എന്ന സ്ട്രിംഗ് തിരയുന്നത് ഫലപ്രദമായി തടഞ്ഞു.) പുരോഗതി ഉറപ്പാക്കാൻ നമുക്ക് ഒരു ചേർക്കാം
"ഉപയോക്തൃനാമം" ആണെങ്കിൽ ഏതെങ്കിലും ഒരു പ്രതീകവുമായി പൊരുത്തപ്പെടുന്ന 'ആരംഭ' നിയമത്തിന് പകരമുള്ള വ്യവസ്ഥ
കണ്ടെത്തിയില്ല.

ആരംഭിക്കുക <- "ഉപയോക്തൃനാമം"
/.

yyparse() ഇപ്പോൾ എല്ലായ്‌പ്പോഴും പൂജ്യമല്ല (ഇൻപുട്ടിന്റെ അവസാനം ഒഴികെ) നൽകുന്നു. ചെയ്യാൻ
ഉപയോഗപ്രദമായ എന്തെങ്കിലും നമുക്ക് നിയമങ്ങളിൽ പ്രവർത്തനങ്ങൾ ചേർക്കാൻ കഴിയും. ഈ പ്രവർത്തനങ്ങൾ a ന് ശേഷം നടപ്പിലാക്കുന്നു
സമ്പൂർണ്ണ പൊരുത്തം കണ്ടെത്തി (ആദ്യ നിയമത്തിൽ നിന്ന് ആരംഭിക്കുന്നു) അവ അനുസരിച്ച് തിരഞ്ഞെടുക്കപ്പെടുന്നു
ഇൻപുട്ടുമായി പൊരുത്തപ്പെടുന്നതിന് വ്യാകരണത്തിലൂടെ എടുത്ത 'പാത്ത്'. (ഭാഷാശാസ്ത്രജ്ഞർ ഈ പാതയെ എ
'വാക്യ മാർക്കർ'.)

ആരംഭിക്കുക <- "ഉപയോക്തൃനാമം" {printf("%s\n", getlogin()); }
/ <. > {putchar(yytext[0]); }

ഉപയോക്താവിന്റെ ലോഗിൻ നാമം കാണുമ്പോഴെല്ലാം പ്രിന്റ് ചെയ്യാൻ ആദ്യ വരി പാർസറോട് നിർദ്ദേശിക്കുന്നു
ഇൻപുട്ടിൽ "ഉപയോക്തൃനാമം". ആ പൊരുത്തം പരാജയപ്പെടുകയാണെങ്കിൽ, രണ്ടാമത്തെ വരി പാഴ്സറോട് പ്രതിധ്വനിക്കാൻ പറയുന്നു
ഇൻപുട്ടിലെ അടുത്ത പ്രതീകം സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട്. ഞങ്ങളുടെ പാർസർ ഇപ്പോൾ ഉപയോഗപ്രദമാണ്
ജോലി: ഇത് "ഉപയോക്തൃനാമത്തിന്റെ" എല്ലാ സംഭവങ്ങളും മാറ്റി പകരം ഔട്ട്പുട്ടിലേക്ക് ഇൻപുട്ട് പകർത്തും
ഉപയോക്താവിന്റെ അക്കൗണ്ട് പേര്.

രണ്ടാമത്തെ ബദലിലേക്ക് ചേർത്ത ആംഗിൾ ബ്രാക്കറ്റുകൾ ('<', '>') ശ്രദ്ധിക്കുക. ഇവ
നിയമത്തിന്റെ അർത്ഥത്തിൽ യാതൊരു സ്വാധീനവുമില്ല, എന്നാൽ ലഭ്യമായ ടെക്‌സ്‌റ്റ് ഡിലിമിറ്റ് ചെയ്യാൻ സഹായിക്കുന്നു
വേരിയബിളിൽ ഇനിപ്പറയുന്ന പ്രവർത്തനം yytext.

മുകളിലുള്ള വ്യാകരണം ഫയലിൽ സ്ഥാപിച്ചിട്ടുണ്ടെങ്കിൽ username.peg, കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നു

പെഗ് -o username.c username.peg

ഫയലിൽ അനുബന്ധ പാഴ്സർ സംരക്ഷിക്കും username.c. ഒരു സമ്പൂർണ്ണ പ്രോഗ്രാം സൃഷ്ടിക്കാൻ
ഈ പാഴ്‌സർ ഒരു സി പ്രോഗ്രാമിന് ഇനിപ്പറയുന്ന രീതിയിൽ ഉൾപ്പെടുത്താം.

#ഉൾപ്പെടുന്നു /* printf(), putchar() */
#ഉൾപ്പെടുന്നു /* getlogin() */

#ഉൾപ്പെടുത്തുക "username.c" /* yyparse() */

int main ()
{
അതേസമയം (yyparse()) /* EOF വരെ ആവർത്തിക്കുക */
;
തിരികെ വരുക;
}

PEG വ്യാകരണങ്ങൾ

ഒരു വ്യാകരണത്തിൽ പേരിട്ടിരിക്കുന്ന നിയമങ്ങളുടെ ഒരു കൂട്ടം അടങ്ങിയിരിക്കുന്നു.

പേര് <- പാറ്റേൺ

ദി പാറ്റേൺ ഇനിപ്പറയുന്ന ഘടകങ്ങളിൽ ഒന്നോ അതിലധികമോ അടങ്ങിയിരിക്കുന്നു.

പേര് നൽകിയിട്ടുള്ള നിയമത്തിലെ മുഴുവൻ പാറ്റേണിനെയും മൂലകം പ്രതിനിധീകരിക്കുന്നു പേര്.

"പ്രതീകങ്ങൾ"
ഇരട്ട ഉദ്ധരണികളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ഒരു പ്രതീകമോ സ്ട്രിംഗോ അക്ഷരാർത്ഥത്തിൽ പൊരുത്തപ്പെടുന്നു. ANSI സി
എസ്കേപ്പ് സീക്വൻസുകൾ ഉള്ളിൽ തിരിച്ചറിയുന്നു പ്രതീകങ്ങൾ.

'പ്രതീകങ്ങൾ'
ഒറ്റ ഉദ്ധരണികളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ഒരു പ്രതീകമോ സ്ട്രിംഗോ മുകളിൽ പറഞ്ഞതുപോലെ അക്ഷരാർത്ഥത്തിൽ പൊരുത്തപ്പെടുന്നു.

[പ്രതീകങ്ങൾ]
സ്ക്വയർ ബ്രാക്കറ്റിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ഒരു കൂട്ടം പ്രതീകങ്ങൾ ഏതെങ്കിലും ഒരു പ്രതീകവുമായി പൊരുത്തപ്പെടുന്നു
മുകളിൽ പറഞ്ഞ പോലെ തിരിച്ചറിഞ്ഞ എസ്കേപ്പ് പ്രതീകങ്ങളുള്ള സെറ്റ്. ഒരു സെറ്റ് ആരംഭിക്കുകയാണെങ്കിൽ
അപ്പാരോ (^) തുടർന്ന് സെറ്റ് നിരാകരിക്കപ്പെടും (ഘടകം ഏത് പ്രതീകവുമായി പൊരുത്തപ്പെടുന്നു അല്ല ലെ
സെറ്റ്). ഒരു ഡാഷ് (-) ഉപയോഗിച്ച് വേർതിരിക്കുന്ന ഏത് ജോടി പ്രതീകങ്ങളും ശ്രേണിയെ പ്രതിനിധീകരിക്കുന്നു
ആദ്യത്തേത് മുതൽ രണ്ടാമത്തേത് വരെയുള്ള പ്രതീകങ്ങൾ ഉൾപ്പെടുന്നു. ഒരൊറ്റ അക്ഷരമാല
അല്ലെങ്കിൽ അണ്ടർസ്‌കോർ ഇനിപ്പറയുന്ന സെറ്റുമായി പൊരുത്തപ്പെടുന്നു.

[a-zA-Z_]

അതുപോലെ, ഇനിപ്പറയുന്നത് ഏതെങ്കിലും ഒറ്റ അക്കമല്ലാത്ത പ്രതീകവുമായി പൊരുത്തപ്പെടുന്നു.

[^0-9]

. ഒരു ഡോട്ട് ഏത് പ്രതീകവുമായി പൊരുത്തപ്പെടുന്നു. ഇത് പരാജയപ്പെടുന്ന ഒരേയൊരു സമയം അവസാനത്തിലാണ് എന്നത് ശ്രദ്ധിക്കുക
ഫയൽ, പൊരുത്തപ്പെടുത്താൻ പ്രതീകം ഇല്ല.

( പാറ്റേൺ )
ഗ്രൂപ്പിംഗിനായി പരാൻതീസിസുകൾ ഉപയോഗിക്കുന്നു (ഓപ്പറേറ്റർമാരുടെ മുൻഗണന പരിഷ്ക്കരിക്കുന്നു
താഴെ വിവരിച്ചിരിക്കുന്നു).

{ നടപടി }
ചുരുണ്ട ബ്രേസുകൾ ചുറ്റുമുള്ള പ്രവർത്തനങ്ങൾ. നടപടി അനിയന്ത്രിതമായ സി സോഴ്സ് കോഡാണ്
പൊരുത്തപ്പെടുത്തലിന്റെ അവസാനം നിർവ്വഹിച്ചു. പ്രവർത്തനത്തിനുള്ളിലെ ഏതെങ്കിലും ബ്രേസുകൾ ശരിയായിരിക്കണം
കൂടുണ്ടാക്കി. പ്രവർത്തനത്തിന് മുമ്പ് പൊരുത്തപ്പെട്ടിരിക്കുന്നതും ആംഗിൾ കൊണ്ട് വേർതിരിച്ചതുമായ ഏതെങ്കിലും ഇൻപുട്ട് വാചകം
പ്രവർത്തനത്തിനുള്ളിൽ ബ്രാക്കറ്റുകൾ (ചുവടെ കാണുക) എന്നതിന്റെ ഉള്ളടക്കമായി ലഭ്യമാക്കിയിട്ടുണ്ട്
പ്രതീക ശ്രേണി yytext. ദൈർഘ്യം (അക്ഷരങ്ങളുടെ എണ്ണം) yytext is
വേരിയബിളിൽ ലഭ്യമാണ് yyleng. (ഈ വേരിയബിൾ പേരുകൾ ചരിത്രപരമാണ്; കാണുക
Lex(1)

< ഒരു ഓപ്പണിംഗ് ആംഗിൾ ബ്രാക്കറ്റ് എല്ലായ്‌പ്പോഴും പൊരുത്തപ്പെടുന്നു (ഇൻപുട്ട് ഉപയോഗിക്കാതെ) ഒപ്പം പാർസറിന് കാരണമാകുന്നു
പൊരുത്തപ്പെടുന്ന വാചകം ശേഖരിക്കാൻ തുടങ്ങുക. ഈ വാചകം പ്രവർത്തനങ്ങൾക്ക് ലഭ്യമാക്കും
വേരിയബിൾ yytext.

> ഒരു ക്ലോസിംഗ് ആംഗിൾ ബ്രാക്കറ്റ് എല്ലായ്‌പ്പോഴും പൊരുത്തപ്പെടുന്നു (ഇൻപുട്ട് ഉപയോഗിക്കാതെ) ഒപ്പം പാഴ്‌സറിന് കാരണമാകുന്നു
വാചകം ശേഖരിക്കുന്നത് നിർത്താൻ yytext.

മുകളിൽ മൂലകംഇനിപ്പറയുന്ന സഫിക്സുകൾ ഉപയോഗിച്ച് s ഓപ്ഷണൽ കൂടാതെ/അല്ലെങ്കിൽ ആവർത്തിക്കാൻ കഴിയും:

മൂലകം ?
ഘടകം ഓപ്ഷണൽ ആണ്. ഇൻപുട്ടിൽ ഉണ്ടെങ്കിൽ, അത് ഉപഭോഗം ചെയ്യുകയും പൊരുത്തപ്പെടുകയും ചെയ്യുന്നു
വിജയിക്കുന്നു. ഇൻപുട്ടിൽ ഇല്ലെങ്കിൽ, ടെക്‌സ്‌റ്റ് ഉപയോഗിക്കില്ല, പൊരുത്തം വിജയിക്കും
എന്തായാലും.

മൂലകം +
ഘടകം ആവർത്തിക്കാവുന്നതാണ്. ഇൻപുട്ടിൽ ഉണ്ടെങ്കിൽ, ഒന്നോ അതിലധികമോ സംഭവങ്ങൾ
മൂലകം കഴിക്കുകയും മത്സരം വിജയിക്കുകയും ചെയ്യുന്നു. സംഭവങ്ങളൊന്നുമില്ലെങ്കിൽ മൂലകം ആകുന്നു
ഇൻപുട്ടിൽ ഉണ്ട്, മത്സരം പരാജയപ്പെടുന്നു.

മൂലകം *
ഘടകം ഓപ്ഷണലും ആവർത്തിക്കാവുന്നതുമാണ്. ഇൻപുട്ടിൽ ഉണ്ടെങ്കിൽ, ഒന്നോ അതിലധികമോ
സംഭവങ്ങൾ മൂലകം കഴിക്കുകയും മത്സരം വിജയിക്കുകയും ചെയ്യുന്നു. സംഭവങ്ങളൊന്നുമില്ലെങ്കിൽ
മൂലകം ഇൻപുട്ടിൽ ഉണ്ട്, മത്സരം എന്തായാലും വിജയിക്കും.

മുകളിലുള്ള മൂലകങ്ങളും പ്രത്യയങ്ങളും പ്രവചനങ്ങളായി പരിവർത്തനം ചെയ്യാവുന്നതാണ് (അത് ഏകപക്ഷീയമായി പൊരുത്തപ്പെടുന്നു
ടെക്സ്റ്റ് ഇൻപുട്ട് ചെയ്യുക, തുടർന്ന് വിജയിക്കുകയോ പരാജയപ്പെടുകയോ ചെയ്യുക കൂടാതെ ആ ഇൻപുട്ട്) ഉപയോഗിച്ച്
ഇനിപ്പറയുന്ന പ്രിഫിക്സുകൾ:

& മൂലകം
എങ്കിൽ മാത്രമേ പ്രവചനം വിജയിക്കൂ മൂലകം പൊരുത്തപ്പെടുത്താനാകും. ടെക്സ്റ്റ് ഇൻപുട്ട് ചെയ്യുമ്പോൾ സ്കാൻ ചെയ്തു
പൊരുത്തപ്പെടുന്നു മൂലകം ഇൻപുട്ടിൽ നിന്ന് ഉപഭോഗം ചെയ്യപ്പെടുന്നില്ല, അവയ്ക്ക് ലഭ്യമാകുന്നു
തുടർന്നുള്ള പൊരുത്തം.

! മൂലകം
എങ്കിൽ മാത്രമേ പ്രവചനം വിജയിക്കൂ മൂലകം പൊരുത്തപ്പെടുത്താൻ കഴിയില്ല. ടെക്സ്റ്റ് ഇൻപുട്ട് ചെയ്യുമ്പോൾ സ്കാൻ ചെയ്തു
പൊരുത്തപ്പെടുന്നു മൂലകം ഇൻപുട്ടിൽ നിന്ന് ഉപഭോഗം ചെയ്യപ്പെടുന്നില്ല, അവയ്ക്ക് ലഭ്യമാകുന്നു
തുടർന്നുള്ള പൊരുത്തം. ഒരു ജനപ്രിയ പദപ്രയോഗമാണ്

!.

ഇൻപുട്ടിന്റെ അവസാന പ്രതീകം ഇതിനകം ഉള്ളതിന് ശേഷം, ഫയലിന്റെ അവസാനവുമായി ഇത് പൊരുത്തപ്പെടുന്നു
ദഹിപ്പിച്ചു.

'&' പ്രവചനത്തിന്റെ ഒരു പ്രത്യേക രൂപം നൽകിയിരിക്കുന്നു:

&{ എക്സ്പ്രഷൻ }
ഇതിൽ ലളിതമായ സി പ്രവചിക്കുക പദപ്രയോഗം (അല്ല പ്രസ്താവന) ഉടനടി വിലയിരുത്തപ്പെടുന്നു
പാഴ്സർ പ്രവചനത്തിൽ എത്തുമ്പോൾ. എങ്കിൽ പദപ്രയോഗം പൂജ്യം അല്ലാത്ത ഫലം നൽകുന്നു (ശരി)
'മാച്ച്' വിജയിക്കുകയും പാറ്റേണിലെ അടുത്ത ഘടകവുമായി പാർസർ തുടരുകയും ചെയ്യുന്നു.
എങ്കില് പദപ്രയോഗം പൂജ്യം നൽകുന്നു (തെറ്റായ) 'പൊരുത്തം' പരാജയപ്പെടുകയും പാഴ്സർ ബാക്കപ്പ് ചെയ്യുകയും ചെയ്യുന്നു
ഇൻപുട്ടിന്റെ ഇതര പാഴ്‌സിനായി നോക്കുക.

നിരവധി ഘടകങ്ങൾ (പ്രിഫിക്സുകളും സഫിക്സുകളും ഉള്ളതോ അല്ലാതെയോ) ഒരു ആയി സംയോജിപ്പിക്കാം ക്രമം
അവ ഒന്നിനുപുറകെ ഒന്നായി എഴുതിക്കൊണ്ടാണ്. ഓരോ വ്യക്തിയും ആണെങ്കിൽ മാത്രമേ മുഴുവൻ ക്രമവും പൊരുത്തപ്പെടൂ
അതിനുള്ളിലെ ഘടകം ഇടത്തുനിന്ന് വലത്തോട്ട് പൊരുത്തപ്പെടുന്നു.

ആൾട്ടർനേഷൻ ഓപ്പറേറ്റർ '/' വഴി സീക്വൻസുകളെ വിഭജിത ബദലുകളായി വേർതിരിക്കാം.

അനുക്രമം-1 / അനുക്രമം-2 / ... / ക്രമം-എൻ
അവയിലൊന്ന് പൊരുത്തപ്പെടുന്നത് വരെ ഓരോ സീക്വൻസും പരീക്ഷിച്ചുനോക്കുന്നു, ആ സമയത്ത് പൊരുത്തപ്പെടുന്നു
മൊത്തത്തിലുള്ള പാറ്റേൺ വിജയിക്കുന്നു. സീക്വൻസുകളൊന്നും പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ പിന്നെ പൊരുത്തം
മൊത്തത്തിലുള്ള പാറ്റേണിന്റെ പരാജയം.

അവസാനമായി, പൗണ്ട് ചിഹ്നം (#) അവസാനം വരെ തുടരുന്ന ഒരു അഭിപ്രായം (നിരസിച്ചു) അവതരിപ്പിക്കുന്നു.
വരിയുടെ.

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

പ്രവചനങ്ങൾ വിലയിരുത്തപ്പെടുന്നു എന്നത് ശ്രദ്ധിക്കുക ഉടനെ വിജയകരമായ ഒരു പൊരുത്തം തിരയുന്നതിനിടയിൽ,
കാരണം അവ തിരയലിന്റെ വിജയത്തിനും പരാജയത്തിനും കാരണമാകുന്നു. എന്നിരുന്നാലും, പ്രവർത്തനങ്ങൾ
വിജയകരമായ ഒരു പൊരുത്തം കണ്ടെത്തിയതിന് ശേഷം മാത്രമേ വിലയിരുത്തൂ.

PEG വ്യാകരണം വേണ്ടി PEG വ്യാകരണങ്ങൾ

എന്നതിനുള്ള വ്യാകരണം പെഗ് വ്യാകരണങ്ങൾ താഴെ കാണിച്ചിരിക്കുന്നു. ഇത് രണ്ടും ചിത്രീകരിക്കുകയും ഔപചാരികമാക്കുകയും ചെയ്യും
മുകളിലെ വിവരണം.

വ്യാകരണം <- സ്‌പെയ്‌സിംഗ് ഡെഫനിഷൻ+ എൻഡ്‌ഓഫ്‌ഫൈൽ

നിർവ്വചനം <- ഐഡന്റിഫയർ LEFTAROW എക്സ്പ്രഷൻ
എക്സ്പ്രഷൻ <- സീക്വൻസ് ( സ്ലാഷ് സീക്വൻസ് )*
ക്രമം <- ഉപസർഗ്ഗം*
പ്രിഫിക്‌സ് <- ഒപ്പം പ്രവർത്തനവും
/ ( കൂടാതെ | അല്ല )? പ്രത്യയം
പ്രത്യയം <- പ്രാഥമികം ( ചോദ്യം / നക്ഷത്രം / പ്ലസ് )?
പ്രാഥമിക <- ഐഡന്റിഫയർ !ഇടത്തേയ്‌ക്ക്
/ തുറക്കുക എക്സ്പ്രഷൻ ക്ലോസ്
/ അക്ഷരാർത്ഥത്തിൽ
/ ക്ലാസ്
/ ഡോട്ട്
/ പ്രവർത്തനം
/ ആരംഭിക്കുന്നു
/ അവസാനിക്കുന്നു

ഐഡന്റിഫയർ <- < IdentStart IdentCont* > സ്പേസിംഗ്
IdentStart <- [a-zA-Z_]
IdentCont <- IdentStart / [0-9]
ലിറ്ററൽ <- ['] < (!['] ചാർ )* > ['] സ്‌പെയ്‌സിംഗ്
/ ["] < (!["] ചാർ )* > ["] സ്പേസിംഗ്
ക്ലാസ് <- '[' < (!']' ശ്രേണി )* > ']' സ്‌പെയ്‌സിംഗ്
ശ്രേണി <- Char '-' Char / Char
ചാർ <- '\\' [abefnrtv'"\[\]\\]
/ '\\' [0-3][0-7][0-7]
/ '\\' [0-7][0-7]?
/ '\\' '-'
/ !'\\' .
ലെഫ്റ്റ്‌ട്രാറോ <- '<-' സ്‌പെയ്‌സിംഗ്
സ്ലാഷ് <- '/' സ്പേസിംഗ്
കൂടാതെ <- '&' സ്‌പെയ്‌സിംഗ്
അല്ല <- '!' സ്പേസിംഗ്
ചോദ്യം <- '?' സ്പേസിംഗ്
STAR <- '*' സ്‌പെയ്‌സിംഗ്
പ്ലസ് <- '+' സ്‌പെയ്‌സിംഗ്
തുറക്കുക <- '(' സ്പേസിംഗ്
CLOSE <- ')' സ്‌പെയ്‌സിംഗ്
ഡോട്ട് <- '.' സ്പേസിംഗ്
സ്‌പെയ്‌സിംഗ് <- ( ഇടം / അഭിപ്രായം )*
അഭിപ്രായം <- '#' ( !EndOfLine . )* EndOfLine
ഇടം <- ' ' / '\t' / EndOfLine
EndOfLine <- '\r\n' / '\n' / '\r'
EndOfFile <- !.
പ്രവർത്തനം <- '{' < [^}]* > '}' സ്‌പെയ്‌സിംഗ്
BEGIN <- '<' സ്പേസിംഗ്
END <- '>' സ്‌പെയ്‌സിംഗ്

കാല് വ്യാകരണങ്ങൾ

കാല് യുടെ ഒരു വകഭേദമാണ് പെഗ് അത് ചില സവിശേഷതകൾ ചേർക്കുന്നു Lex(1) ഉം yac(1). അതിൽ നിന്ന് വ്യത്യസ്തമാണ്
പെഗ് ഇനിപ്പറയുന്ന വഴികളിൽ.

%{ ടെക്സ്റ്റ്... %}
ഒരു റൂൾ നിർവചനം പ്രതീക്ഷിക്കുന്ന എവിടെയും ഒരു ഡിക്ലറേഷൻ വിഭാഗം ദൃശ്യമാകും. ദി
ടെക്സ്റ്റ് '%{', '%}' എന്നീ ഡിലിമിറ്ററുകൾക്കിടയിൽ, ജനറേറ്റുചെയ്ത C-യിലേക്ക് പദാനുപദമായി പകർത്തുന്നു
പാർസർ കോഡ് മുമ്പ് പാഴ്‌സർ തന്നെ നടപ്പിലാക്കുന്ന കോഡ്.

പേര് = പാറ്റേൺ
'അസൈൻമെന്റ്' ഓപ്പറേറ്റർ ഇടത് ആരോ ഓപ്പറേറ്റർ '<-' മാറ്റിസ്ഥാപിക്കുന്നു.

ഭരണം-പേര്
നിയമങ്ങളുടെ പേരുകളിൽ ഹൈഫനുകൾ അക്ഷരങ്ങളായി പ്രത്യക്ഷപ്പെടാം. ഓരോ ഹൈഫനും പരിവർത്തനം ചെയ്യപ്പെടുന്നു
ജനറേറ്റുചെയ്‌ത സി സോഴ്‌സ് കോഡിലെ ഒരു അടിവര. ഒരൊറ്റ ഹൈഫൻ '-' ആണ് a
നിയമപരമായ നിയമത്തിന്റെ പേര്.

- = [ \t\n\r]*
നമ്പർ = [0-9]+ -
പേര് = [a-zA-Z_][a-zA_Z_0-9]* -
l-paren = '(' -
r-paren = ')' -

വ്യാകരണം വായിക്കുമ്പോൾ അവഗണിക്കപ്പെട്ട വൈറ്റ്‌സ്‌പേസ് എങ്ങനെ വ്യക്തമാകുമെന്ന് ഈ ഉദാഹരണം കാണിക്കുന്നു
എന്നിട്ടും ബന്ധപ്പെട്ട എല്ലാ നിയമങ്ങളുടെയും അവസാനം ഉദാരമായി സ്ഥാപിക്കുമ്പോൾ തടസ്സമില്ലാത്തത്
ഒരു ലെക്സിക്കൽ ഘടകം.

seq-1 | seq-2
ആൾട്ടർനേഷൻ ഓപ്പറേറ്റർ ലംബ ബാർ '|' ആണ് ഫോർവേഡ് സ്ലാഷ് '/' എന്നതിലുപരി. ദി
പെഗ് ഭരണം

പേര് <- ക്രമം-1
/ ക്രമം-2
/ ക്രമം-3

അതുകൊണ്ട് എഴുതിയിരിക്കുന്നു

പേര് = ക്രമം-1
| അനുക്രമം-2
| അനുക്രമം-3
;

in കാല് (അവസാന അർദ്ധവിരാമം ഓപ്ഷണൽ ആയതിനാൽ, അടുത്തതായി വിവരിക്കുന്നത് പോലെ).

exp ~ { നടപടി }
ഒരു പോസ്റ്റ്ഫിക്സ് ഓപ്പറേറ്റർ ~{ നടപടി } ഏതെങ്കിലും പദപ്രയോഗത്തിന് ശേഷം സ്ഥാപിക്കുകയും പെരുമാറുകയും ചെയ്യും
ഒരു സാധാരണ പ്രവർത്തനം പോലെ (അനിയന്ത്രിതമായ സി കോഡ്) അത് എപ്പോൾ മാത്രമേ അഭ്യർത്ഥിക്കുകയുള്ളൂ exp
പരാജയപ്പെടുന്നു. ആൾട്ടർനേഷൻ ഒഴികെയുള്ള മറ്റേതൊരു ഓപ്പറേറ്ററെക്കാളും ഇത് കുറച്ച് ദൃഢമായി ബന്ധിപ്പിക്കുന്നു
ക്രമപ്പെടുത്തൽ, കൂടാതെ പിശക് കൈകാര്യം ചെയ്യലും വീണ്ടെടുക്കൽ കോഡും എളുപ്പമാക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്
എഴുതുക. അതല്ല yytext ഒപ്പം yyleng ഈ പ്രവൃത്തികൾക്കുള്ളിൽ ലഭ്യമല്ല, എന്നാൽ
പോയിന്റർ വേരിയബിൾ yy ഉപയോക്താവ് നിർവചിച്ചിട്ടുള്ള ഏതൊരു വ്യക്തിക്കും കോഡ് ആക്സസ് നൽകാൻ ലഭ്യമാണ്
പാർസർ സ്റ്റേറ്റിലെ അംഗങ്ങൾ (ചുവടെയുള്ള "പാർസർ ഇഷ്‌ടാനുസൃതമാക്കൽ" കാണുക). അതും ശ്രദ്ധിക്കുക
exp എല്ലായ്പ്പോഴും ഒരൊറ്റ പദപ്രയോഗമാണ്; ഉള്ളിലെ ഏതെങ്കിലും പരാജയത്തിന് ഒരു പിശക് നടപടി അഭ്യർത്ഥിക്കാൻ
ഒരു സീക്വൻസ്, സീക്വൻസിനെ ഒരു സിംഗിൾ ആയി ഗ്രൂപ്പുചെയ്യാൻ പരാൻതീസിസ് ഉപയോഗിക്കണം
എക്സ്പ്രഷൻ.

നിയമം = e1 e2 e3 ~{ പിശക് ("ഇ[12] ശരി; e3 പരാജയപ്പെട്ടു"); }
| ...

നിയമം = (e1 e2 e3) ~{ പിശക് ("ഇയിൽ ഒന്ന്[123] പരാജയപ്പെട്ടു"); }
| ...

പാറ്റേൺ ;
ഒരു അർദ്ധവിരാമ ചിഹ്നത്തിന് ഓപ്ഷണലായി അവസാനിപ്പിക്കാം a പാറ്റേൺ.

%% ടെക്സ്റ്റ്...
ഒരു ഇരട്ട ശതമാനം '%%' നിയമങ്ങളുടെ (ഡിക്ലറേഷനുകളും) വിഭാഗത്തെ അവസാനിപ്പിക്കുന്നു
വ്യാകരണം. എല്ലാം ടെക്സ്റ്റ് ഇനിപ്പറയുന്ന '%%' ജനറേറ്റുചെയ്‌ത സി പാഴ്‌സർ കോഡിലേക്ക് പദാനുപദമായി പകർത്തുന്നു
ശേഷം പാർസർ നടപ്പിലാക്കൽ കോഡ്.

$$ = മൂല്യം
ഒരു ഉപനിയമത്തിന് ഒരു സെമാന്റിക് തിരികെ നൽകാൻ കഴിയും മൂല്യം ഒരു പ്രവർത്തനത്തിൽ നിന്ന് അത് ഏൽപ്പിച്ചുകൊണ്ട്
വ്യാജ വേരിയബിൾ '$$'. എല്ലാ സെമാന്റിക് മൂല്യങ്ങൾക്കും ഒരേ തരം ഉണ്ടായിരിക്കണം (അത് ഡിഫോൾട്ടാണ്
'int' വരെ). ഒരു ഡിക്ലറേഷൻ വിഭാഗത്തിൽ YYSTYPE നിർവ്വചിച്ചുകൊണ്ട് ഈ തരം മാറ്റാവുന്നതാണ്.

ഐഡന്റിഫയർ:പേര്
ഉപനിയമത്തിൽ നിന്ന് സെമാന്റിക് മൂല്യം ('$$' ലേക്ക് അസൈൻ ചെയ്യുന്നതിലൂടെ) തിരികെ നൽകി പേര് is
ഇതുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു ഐഡന്റിഫയർ തുടർന്നുള്ള പ്രവർത്തനങ്ങളിൽ പരാമർശിക്കാവുന്നതാണ്.

ചുവടെയുള്ള ഡെസ്ക് കാൽക്കുലേറ്റർ ഉദാഹരണം '$$', ':' എന്നിവയുടെ ഉപയോഗം വ്യക്തമാക്കുന്നു.

കാല് ഉദാഹരണം: A Desk കാൽക്കുലേറ്റർ

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

%{
#ഉൾപ്പെടുന്നു /* printf() */
#ഉൾപ്പെടുന്നു /* atoi() */
int vars[26];
%}

Stmt = - e:Expr EOL {printf("%d\n", e); }
| ( !EOL . )* EOL {printf("error\n"); }

Expr = i:ID ASSIGN s:Sum {$$ = vars[i] = s; }
| s:Sum {$$ = s; }

തുക = l: ഉൽപ്പന്നം
( പ്ലസ് r:ഉൽപ്പന്നം { l += r; }
| MINUS r:ഉൽപ്പന്നം { l -= r; }
)* {$$ = l; }

ഉൽപ്പന്നം = l:മൂല്യം
( TIMES r:മൂല്യം {l *= r; }
| ഡിവൈഡ് r:മൂല്യം {l /= r; }
)* {$$ = l; }

മൂല്യം = i:NUMBER {$$ = atoi(yytext); }
| i:ID !ASSIGN {$$ = vars[i]; }
| OPEN i:Expr ക്ലോസ് {$$ = i; }

NUMBER = < [0-9]+ > - {$$ = atoi(yytext); }
ID = < [az] > - {$$ = yytext[0] - 'a'; }
നിയോഗിക്കുക = '=' -
പ്ലസ് = '+' -
MINUS = '-' -
സമയങ്ങൾ = '*' -
DIVIDE = '/' -
തുറക്കുക = '(' -
CLOSE = ')' -

- = [ \t]*
EOL = '\n' | '\r\n' | '\r' | ';'

%%

int main ()
{
അതേസമയം (yyparse())
;
തിരികെ വരുക;
}

കാല് വ്യാകരണം വേണ്ടി കാല് വ്യാകരണങ്ങൾ

എന്നതിനുള്ള വ്യാകരണം കാല് വ്യാകരണങ്ങൾ താഴെ കാണിച്ചിരിക്കുന്നു. ഇത് രണ്ടും ചിത്രീകരിക്കുകയും ഔപചാരികമാക്കുകയും ചെയ്യും
മുകളിലെ വിവരണം.

വ്യാകരണം = -
(പ്രഖ്യാപനം | നിർവചനം)+
ട്രെയിലർ? ഫയലിന്റെ അവസാനം

declaration = '%{' < (!'%}' . )* > RPERCENT

ട്രെയിലർ = '%%' < .* >

നിർവചനം = ഐഡന്റിഫയർ EQUAL എക്സ്പ്രഷൻ SEMICOLON?

എക്സ്പ്രഷൻ = സീക്വൻസ് (BAR സീക്വൻസ്)*

ക്രമം = പിശക്+

പിശക് = പ്രിഫിക്സ് (TILDE പ്രവർത്തനം)?

പ്രിഫിക്‌സ് = AND ആക്ഷൻ
| ( കൂടാതെ | അല്ല )? പ്രത്യയം

suffix = പ്രാഥമികം (QUERY | STAR | പ്ലസ് )?

പ്രാഥമിക = ഐഡന്റിഫയർ COLON ഐഡന്റിഫയർ !EQUAL
| ഐഡന്റിഫയർ !EQUAL
| ഓപ്പൺ എക്സ്പ്രഷൻ ക്ലോസ്
| അക്ഷരാർത്ഥത്തിൽ
| ക്ലാസ്
| ഡോട്ട്
| നടപടി
| ആരംഭിക്കുന്നു
| അവസാനിക്കുന്നു

ഐഡന്റിഫയർ = < [-a-zA-Z_][-a-zA-Z_0-9]* > -

ലിറ്ററൽ = ['] < (!['] char )* > ['] -
| ["] < (!["] char )* > ["] -

class = '[' < (!']' ശ്രേണി )* > ']' -

ശ്രേണി = char '-' char | ചാർ

char = '\\' [abefnrtv'"\[\]\\]
| '\\' [0-3][0-7][0-7]
| '\\' [0-7][0-7]?
| !'\\' .

action = '{' < braces* > '}' -

ബ്രേസുകൾ = '{' ബ്രേസുകൾ* '}'
| !'}' .

തുല്യം = '=' -
കോളൻ = ':' -
സെമിക്കോളൺ = ';' -
BAR = '|' -
ഒപ്പം = '&' -
അല്ല = '!' -
ചോദ്യം = '?' -
നക്ഷത്രം = '*' -
പ്ലസ് = '+' -
തുറക്കുക = '(' -
CLOSE = ')' -
DOT = '.' -
BEGIN = '<' -
END = '>' -
TILDE = '~' -
RPERCENT = '%}' -

- = (സ്പെയ്സ് | അഭിപ്രായം )*
ഇടം = ' ' | '\t' | അവസാന വരി
കമന്റ് = '#' (! end-of-line. )* end-of-line
end-of-line = '\r\n' | '\n' | '\r'
ഫയലിന്റെ അവസാനം = !.

ഇഷ്ടാനുസൃതമാക്കൽ ദി പാർസർ

ജനറേറ്റ് ചെയ്‌തത് പരിഷ്‌ക്കരിക്കുന്നതിന് ഇനിപ്പറയുന്ന ചിഹ്നങ്ങൾ ഡിക്ലറേഷൻ വിഭാഗങ്ങളിൽ പുനർ നിർവചിക്കാം
പാർസർ കോഡ്.

YYSTYPE
സെമാന്റിക് മൂല്യത്തിന്റെ തരം. '$$' എന്ന വ്യാജ വേരിയബിളും ഐഡന്റിഫയറുകളും 'ബൗണ്ട്' ചെയ്യുന്നു
കോളൻ ഓപ്പറേറ്ററുമായുള്ള റൂൾ ഫലങ്ങൾ ':' എല്ലാം പ്രഖ്യാപിച്ചതായി കണക്കാക്കണം
ഈ തരം ഉണ്ടായിരിക്കാൻ. സ്ഥിര മൂല്യം 'int' ആണ്.

YYPARSE
പാർസറിലേക്കുള്ള പ്രധാന എൻട്രി പോയിന്റിന്റെ പേര്. സ്ഥിര മൂല്യം 'yyparse' ആണ്.

YYPARSEFROM
പാർസറിലേക്കുള്ള ഒരു ഇതര എൻട്രി പോയിന്റിന്റെ പേര്. ഈ പ്രവർത്തനം ഒന്ന് പ്രതീക്ഷിക്കുന്നു
വാദം: ഒരു പൊരുത്തത്തിനായി തിരയുന്ന നിയമവുമായി ബന്ധപ്പെട്ട ഫംഗ്ഷൻ
തുടങ്ങണം. സ്ഥിരസ്ഥിതി 'yyparsefrom' ആണ്. yyparse() എന്ന് നിർവചിച്ചിരിക്കുന്നത് ശ്രദ്ധിക്കുക

int yyparse() {yparsefrom(yy_foo) മടങ്ങുക; }

ഇവിടെ 'foo' എന്നത് വ്യാകരണത്തിലെ ആദ്യത്തെ നിയമത്തിന്റെ പേരാണ്.

YY_INPUT(buf, ഫലം, max_size)
കൂടുതൽ ഇൻപുട്ട് ടെക്‌സ്‌റ്റ് ലഭിക്കുന്നതിന് പാഴ്‌സർ ഈ മാക്രോ അഭ്യർത്ഥിക്കുന്നു. buf ഒരു ചൂണ്ടിക്കാണിക്കുന്നു
ഏറ്റവും കൂടുതൽ സൂക്ഷിക്കാൻ കഴിയുന്ന മെമ്മറിയുടെ മേഖല max_size കഥാപാത്രങ്ങൾ. മാക്രോ പകർത്തണം
എന്നതിലേക്ക് ടെക്സ്റ്റ് ഇൻപുട്ട് ചെയ്യുക buf തുടർന്ന് പൂർണ്ണസംഖ്യ വേരിയബിൾ നൽകുക ഫലം സൂചിപ്പിക്കാൻ
പകർത്തിയ പ്രതീകങ്ങളുടെ എണ്ണം. കൂടുതൽ ഇൻപുട്ട് ലഭ്യമല്ലെങ്കിൽ, മാക്രോ ചെയ്യണം
0 ലേക്ക് അസൈൻ ചെയ്യുക ഫലം. സ്ഥിരസ്ഥിതിയായി, YY_INPUT മാക്രോ ഇനിപ്പറയുന്ന രീതിയിൽ നിർവചിച്ചിരിക്കുന്നു.

#നിർവ്വചിക്കുക YY_INPUT(ബഫ്, ഫലം, പരമാവധി_വലുപ്പം) \
{\
int yyc= getchar(); \
ഫലം= (EOF == yyc) ? 0 : (*(buf)= yyc, 1); \
}

YY_CTX_LOCAL നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ (ചുവടെ കാണുക) ഒരു അധിക ആദ്യ വാദം,
പാഴ്‌സർ സന്ദർഭം ഉൾക്കൊള്ളുന്നത്, YY_INPUT-ലേക്ക് കൈമാറുന്നു.

YY_DEBUG
ഈ ചിഹ്നങ്ങൾ നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ, പാർസറിൽ അധിക കോഡ് ഉൾപ്പെടുത്തും
പാഴ്‌സർ ചെയ്യുമ്പോൾ സാധാരണ പിശകിലേക്ക് വലിയ അളവിലുള്ള ആർക്കെയ്ൻ വിവരങ്ങൾ പ്രിന്റ് ചെയ്യുന്നു
ഓടിക്കൊണ്ടിരിക്കുന്നു.

YY_BEGIN
ലഭ്യമാക്കുന്ന ഇൻപുട്ട് ടെക്‌സ്‌റ്റിന്റെ ആരംഭം അടയാളപ്പെടുത്താൻ ഈ മാക്രോ അഭ്യർത്ഥിക്കുന്നു
പ്രവർത്തനങ്ങളിൽ 'yytext'. ഇത് വ്യാകരണത്തിലെ '<' സംഭവങ്ങളുമായി പൊരുത്തപ്പെടുന്നു.
ഇവ വിജയിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്ന പ്രവചനങ്ങളായി പരിവർത്തനം ചെയ്യപ്പെടുന്നു. സ്ഥിരസ്ഥിതി
നിര്വചനം

#YY_BEGIN നിർവ്വചിക്കുക (yybegin= yypos, 1)

അതിനാൽ നിലവിലെ ഇൻപുട്ട് സ്ഥാനം സംരക്ഷിക്കുകയും അതിന്റെ ഫലമായി 1 ('ശരി') നൽകുകയും ചെയ്യുന്നു
പ്രവചനം.

YY_END ഈ മാക്രോസ് വ്യാകരണത്തിലെ '>' എന്നതിനോട് യോജിക്കുന്നു. വീണ്ടും, ഇത് ഒരു പ്രവചനമാണ്, അതിനാൽ
സ്ഥിരസ്ഥിതി നിർവചനം 'വിജയിക്കുന്നതിന്' മുമ്പ് ഇൻപുട്ട് സ്ഥാനം സംരക്ഷിക്കുന്നു.

#YY_END നിർവ്വചിക്കുക (വർഷാവസാനം= yypos, 1)

YY_PARSE(T)
ഈ മാക്രോ പാഴ്‌സർ എൻട്രി പോയിന്റുകൾ (yyparse, yyparsefrom) തരം ആണെന്ന് പ്രഖ്യാപിക്കുന്നു
T. സ്ഥിര നിർവചനം

#YY_PARSE(T)T നിർവ്വചിക്കുക

ആഗോള ദൃശ്യപരതയോടെ yyparse(), yyparsefrom() എന്നിവ വിടുന്നു. അവർ പാടില്ല എങ്കിൽ
മറ്റ് ഉറവിട ഫയലുകളിൽ ബാഹ്യമായി ദൃശ്യമാണ്, ഈ മാക്രോ ഡിക്ലെയർ ചെയ്യാൻ പുനർ നിർവചിക്കാം
അവ 'സ്റ്റാറ്റിക്'.

#YY_PARSE(T) സ്റ്റാറ്റിക് T നിർവചിക്കുക

YY_CTX_LOCAL
ജനറേറ്റ് ചെയ്‌ത പാഴ്‌സർ കംപൈൽ ചെയ്യുമ്പോൾ ഈ ചിഹ്നം നിർവചിക്കപ്പെട്ടാൽ ഗ്ലോബൽ
പാഴ്‌സർ അവസ്ഥ പ്രഖ്യാപിക്കാവുന്ന തരത്തിൽ 'yycontext' എന്ന ഘടനയിൽ സൂക്ഷിക്കും
ഒരു പ്രാദേശിക വേരിയബിളായി. പാഴ്‌സറുകളുടെ ഒന്നിലധികം സന്ദർഭങ്ങളെ ഒന്നിച്ച് നിലനിൽക്കാനും പ്രവർത്തിക്കാനും ഇത് അനുവദിക്കുന്നു
ത്രെഡ്-സേഫ് ആയിരിക്കുക. പാഴ്സിംഗ് ഫംഗ്ഷൻ yyparse() ആദ്യത്തേത് പ്രതീക്ഷിക്കുന്നതിനായി പ്രഖ്യാപിക്കും
'Yycontext *' എന്ന തരത്തിലുള്ള വാദം, ആഗോളതലത്തെ പിടിച്ചുനിർത്തുന്ന ഘടനയുടെ ഉദാഹരണം
പാർസറിനുള്ള അവസ്ഥ. ഈ സന്ദർഭം അനുവദിച്ച് പൂജ്യത്തിലേക്ക് ആരംഭിക്കണം
ക്ലയന്റ്. നിസ്സാരവും എന്നാൽ പൂർണ്ണവുമായ ഒരു ഉദാഹരണം ഇനിപ്പറയുന്നതാണ്.

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

#YY_CTX_LOCAL നിർവ്വചിക്കുക

#ഉൾപ്പെടുത്തുക "the-generated-parser.peg.c"

int main ()
{
yy സന്ദർഭം ctx;
മെംസെറ്റ്(&ctx, 0, sizeof(yycontext));
അതേസമയം (yyparse(&ctx));
തിരികെ വരുക;
}

ഈ ചിഹ്നം നിർവചിച്ചിട്ടില്ലെങ്കിൽ, കംപൈൽ ചെയ്ത പാഴ്സർ സ്ഥിരമായി മാറുമെന്നത് ശ്രദ്ധിക്കുക
അതിന്റെ ആഗോള നില അനുവദിക്കുക, അത് വീണ്ടും പ്രവേശിക്കുകയോ ത്രെഡ്-സേഫ് ആയിരിക്കുകയോ ചെയ്യില്ല. കൂടി ശ്രദ്ധിക്കുക
പാഴ്സർ yy സന്ദർഭ ഘടന ആദ്യമായി സ്വയമേവ ആരംഭിക്കുന്നു
yyparse() വിളിച്ചു; ഈ ഘടന ആവശമാകുന്നു അതിനാൽ പൂജ്യത്തിലേക്ക് ശരിയായി ആരംഭിക്കുക
ആദ്യ കോളിന് മുമ്പ് yyparse().

YY_CTX_MEMBERS
YY_CTX_LOCAL നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ (മുകളിൽ കാണുക) മാക്രോ YY_CTX_MEMBERS നിർവചിക്കാനാകും
ക്ലയന്റ് ആഗ്രഹിക്കുന്ന ഏതെങ്കിലും അധിക അംഗ ഫീൽഡ് ഡിക്ലറേഷനുകളിലേക്ക് വിപുലീകരിക്കാൻ
'Yycontext' ഘടനയുടെ പ്രഖ്യാപനത്തിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. ഈ അധിക
ജനറേറ്റ് ചെയ്‌ത പാഴ്‌സർ അംഗങ്ങളെ അവഗണിക്കുന്നു. 'Yy സന്ദർഭം' എന്നതിന്റെ ഉദാഹരണം
നിലവിൽ സജീവമായ പാഴ്‌സറുമായി ബന്ധപ്പെട്ടത് പ്രവർത്തനങ്ങളിൽ ലഭ്യമാണ്
പോയിന്റർ വേരിയബിൾ yy.

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

YY_STACK_SIZE
വേരിയബിളിന്റെയും ആക്ഷൻ സ്റ്റാക്കുകളുടെയും പ്രാരംഭ വലുപ്പം. സ്ഥിരസ്ഥിതി 128 ആണ്, അതായത്
പാഴ്‌സിംഗ് സമയത്ത് ആവശ്യം നിറവേറ്റാൻ ആവശ്യമുള്ളപ്പോഴെല്ലാം ഇരട്ടിയായി. ഉള്ള അപേക്ഷകൾ
നിരവധി ലോക്കൽ വേരിയബിളുകളുള്ള ആഴത്തിലുള്ള കോൾ സ്റ്റാക്കുകൾ, അല്ലെങ്കിൽ a ന് ശേഷം നിരവധി പ്രവർത്തനങ്ങൾ നടത്തുന്നു
ഒരു വിജയകരമായ പൊരുത്തം, അനാവശ്യ ബഫർ ഒഴിവാക്കാൻ ഇത് വർദ്ധിപ്പിക്കും
പുനർവിന്യാസം.

YY_MALLOC(YY, SIZE)
പാഴ്‌സറുമായി ബന്ധപ്പെട്ട എല്ലാ സ്റ്റോറേജുകൾക്കുമുള്ള മെമ്മറി അലോക്കേറ്റർ. പരാമീറ്ററുകൾ ആകുന്നു
നിലവിലെ yy സന്ദർഭ ഘടനയും അനുവദിക്കേണ്ട ബൈറ്റുകളുടെ എണ്ണവും. സ്ഥിരസ്ഥിതി
നിർവ്വചനം ഇതാണ്: malloc(SIZE)

YY_REALLOC(YY, പി.ടി.ആർ, SIZE)
ചലനാത്മകമായി വളർന്ന സംഭരണത്തിനായുള്ള മെമ്മറി റിയലോക്കേറ്റർ (ടെക്‌സ്റ്റ് ബഫറുകളും പോലുള്ളവയും
വേരിയബിൾ സ്റ്റാക്കുകൾ). പാരാമീറ്ററുകൾ നിലവിലെ yy സന്ദർഭ ഘടനയാണ്, the
മുമ്പ് അനുവദിച്ച സംഭരണവും ആ സ്റ്റോറേജ് ചെയ്യേണ്ട ബൈറ്റുകളുടെ എണ്ണവും
വളരും. ഡിഫോൾട്ട് നിർവചനം ഇതാണ്: realloc(പി.ടി.ആർ, SIZE)

YY_FREE(YY, പി.ടി.ആർ)
മെമ്മറി ഡീലോക്കേറ്റർ. പാരാമീറ്ററുകൾ നിലവിലെ yy സന്ദർഭ ഘടനയും the
ഡീലോക്കേറ്റ് ചെയ്യാനുള്ള സംഭരണം. ഡിഫോൾട്ട് നിർവചനം ഇതാണ്: free(പി.ടി.ആർ)

YYRELEASE
ഒരു yy സന്ദർഭ ഘടനയാൽ കൈവശമുള്ള എല്ലാ ഉറവിടങ്ങളും റിലീസ് ചെയ്യുന്ന ഫംഗ്ഷന്റെ പേര്.
സ്ഥിര മൂല്യം 'yyrelease' ആണ്.

പ്രവർത്തനങ്ങളിൽ താഴെ പറയുന്ന വേരിയബിളുകൾ സൂചിപ്പിക്കാം.

പ്രതീകം *yybuf
ഈ വേരിയബിൾ ഇൻപുട്ട് ടെക്‌സ്‌റ്റ് സംഭരിക്കാൻ ഉപയോഗിക്കുന്ന പാർസറിന്റെ ഇൻപുട്ട് ബഫറിലേക്ക് പോയിന്റ് ചെയ്യുന്നു
ഇതുവരെ പൊരുത്തപ്പെട്ടിട്ടില്ല.

int yypos
പൊരുത്തപ്പെടുത്താനും ഉപയോഗിക്കാനുമുള്ള അടുത്ത പ്രതീകത്തിന്റെ (yybuf-ൽ) ഇതാണ്.

പ്രതീകം *Yytext
'<', '>' എന്നിവയാൽ വേർതിരിച്ച ഏറ്റവും പുതിയ പൊരുത്തപ്പെടുത്തൽ ടെക്‌സ്‌റ്റ് ഈ വേരിയബിളിൽ സംഭരിച്ചിരിക്കുന്നു.

int yyleng
ഈ വേരിയബിൾ 'yytext' ലെ പ്രതീകങ്ങളുടെ എണ്ണം സൂചിപ്പിക്കുന്നു.

സന്ദർഭം *yy
ഈ വേരിയബിൾ ചൂണ്ടിക്കാണിക്കുന്നത് 'Yycontext' എന്നതുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു
നിലവിൽ സജീവമായ പാഴ്സർ.

ഒരു പാർസറുമായി ബന്ധപ്പെട്ട എല്ലാ ഉറവിടങ്ങളും റിലീസ് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന പ്രോഗ്രാമുകൾക്ക് ഇത് ഉപയോഗിക്കാം
ഇനിപ്പറയുന്ന പ്രവർത്തനം.

വർഷം റിലീസ്(yy സന്ദർഭം*yy)
ഇതുമായി ബന്ധപ്പെട്ട എല്ലാ പാർസർ അനുവദിച്ച സ്റ്റോറേജും നൽകുന്നു yy സിസ്റ്റത്തിലേക്ക്. സംഭരണം
അടുത്ത കോളിൽ വീണ്ടും അനുവദിക്കും yyparse().

yy സന്ദർഭ ഘടനയ്ക്കുള്ള സംഭരണം ഒരിക്കലും അനുവദിക്കുകയോ വീണ്ടെടുക്കുകയോ ചെയ്യുന്നില്ല എന്നത് ശ്രദ്ധിക്കുക
പരോക്ഷമായി. ആപ്ലിക്കേഷൻ ഈ ഘടനകളെ സ്വയമേവയുള്ള സംഭരണത്തിലോ ഉപയോഗത്തിലോ അനുവദിക്കണം
കാലോക്ക്() ഒപ്പം സ്വതന്ത്ര() അവരെ വ്യക്തമായി കൈകാര്യം ചെയ്യാൻ. ഇനിപ്പറയുന്ന വിഭാഗത്തിലെ ഉദാഹരണം
റിസോഴ്സ് മാനേജ്മെന്റിനുള്ള ഒരു സമീപനം കാണിക്കുന്നു.

കാല് ഉദാഹരണം: വിപുലീകരിക്കുന്നു ദി പാർസറുകൾ CONTEXT

ദി yy പ്രവർത്തനങ്ങളിലേക്ക് പാസാക്കിയ വേരിയബിളിൽ പാർസറിന്റെ അവസ്ഥയും കൂടാതെ ഏതെങ്കിലും അധികവും അടങ്ങിയിരിക്കുന്നു
YY_CTX_MEMBERS നിർവ്വചിച്ച ഫീൽഡുകൾ. ആപ്ലിക്കേഷൻ-നിർദ്ദിഷ്ട സംഭരിക്കാൻ തീസ് ഫീൽഡുകൾ ഉപയോഗിക്കാം
ഒരു പ്രത്യേക കോളിന് ആഗോളമായ വിവരങ്ങൾ yyparse(). നിസ്സാരവും എന്നാൽ പൂർണ്ണവുമായ ഒന്ന് കാല്
yy സന്ദർഭ ഘടന a ഉപയോഗിച്ച് നീട്ടിയിരിക്കുന്ന ഉദാഹരണം ഇനിപ്പറയുന്നു എണ്ണുക സംഖ്യയുടെ
ഇതുവരെയുള്ള ഇൻപുട്ടിൽ കണ്ട ന്യൂലൈൻ പ്രതീകങ്ങൾ (വ്യാകരണം അല്ലാത്തപക്ഷം ഉപയോഗിക്കുകയും അവഗണിക്കുകയും ചെയ്യുന്നു
മുഴുവൻ ഇൻപുട്ടും). വിളിക്കുന്നയാൾ yyparse() ഉപയോഗിക്കുന്നു എണ്ണുക എന്ന വരികളുടെ എണ്ണം പ്രിന്റ് ചെയ്യാൻ
വായിച്ച ഇൻപുട്ട്.

%{
#YY_CTX_LOCAL 1 നിർവ്വചിക്കുക
#YY_CTX_MEMBERS \
int എണ്ണം;
%}

Char = ('\n' | '\r\n' | '\r') {yy->count++ }
| .

%%

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

int main ()
{
/* ഓട്ടോമാറ്റിക് സ്റ്റോറേജിൽ ഒരു പ്രാദേശിക പാഴ്സർ സന്ദർഭം സൃഷ്ടിക്കുക */
yy സന്ദർഭം yy;
/* സന്ദർഭം *ആദ്യ ഉപയോഗത്തിന് മുമ്പ് പൂജ്യത്തിലേക്ക് ആരംഭിക്കണം*/
മെംസെറ്റ്(&yy, 0, sizeof(yy));

അതേസമയം (yyparse(&yy))
;
printf("%d ന്യൂലൈനുകൾ\n", yy.count);

/* സന്ദർഭവുമായി ബന്ധപ്പെട്ട എല്ലാ ഉറവിടങ്ങളും റിലീസ് ചെയ്യുക */
yyrelease(&yy);

തിരികെ വരുക;
}

ഡയഗ്നോസ്റ്റിക്സ്

പെഗ് ഒപ്പം കാല് ഒരു വ്യാകരണം പാഴ്‌സറാക്കി മാറ്റുമ്പോൾ ഇനിപ്പറയുന്ന വ്യവസ്ഥകളെക്കുറിച്ച് മുന്നറിയിപ്പ് നൽകുക.

സിന്റാക്സ് പിശക്
ഇൻപുട്ട് വ്യാകരണം ചില വിധത്തിൽ വികലമായി. പിശക് സന്ദേശത്തിൽ ഉൾപ്പെടും
പൊരുത്തപ്പെടുത്താൻ പോകുന്ന വാചകം (പലപ്പോഴും യഥാർത്ഥ സ്ഥലത്ത് നിന്ന് ഒരു വലിയ തുക ബാക്കപ്പ് ചെയ്യുന്നു
പിശക്) കൂടാതെ ഏറ്റവും അടുത്തിടെ പരിഗണിക്കപ്പെട്ട പ്രതീകത്തിന്റെ ലൈൻ നമ്പറും (അതായത്
പലപ്പോഴും പ്രശ്നത്തിന്റെ യഥാർത്ഥ സ്ഥാനം).

ഭരണം 'foo' ഉപയോഗിച്ച പക്ഷേ അല്ല നിർവചിച്ചിരിക്കുന്നത്
വ്യാകരണം 'foo' എന്ന് പേരുള്ള ഒരു നിയമത്തെ പരാമർശിക്കുന്നു, പക്ഷേ അതിന് ഒരു നിർവചനവും നൽകിയിട്ടില്ല.
ജനറേറ്റ് ചെയ്‌ത പാഴ്‌സർ ഉപയോഗിക്കാൻ ശ്രമിക്കുന്നത് ലിങ്കറിൽ നിന്നുള്ള പിശകുകൾക്ക് കാരണമാകും
നഷ്‌ടമായ നിയമവുമായി ബന്ധപ്പെട്ട നിർവചിക്കാത്ത ചിഹ്നങ്ങൾ കാരണം.

ഭരണം 'foo' നിർവചിച്ചിരിക്കുന്നത് പക്ഷേ അല്ല ഉപയോഗിച്ച
വ്യാകരണം 'foo' എന്ന് പേരുള്ള ഒരു നിയമം നിർവചിക്കുകയും പിന്നീട് അത് അവഗണിക്കുകയും ചെയ്തു. ബന്ധപ്പെട്ട കോഡ്
റൂളിനൊപ്പം ജനറേറ്റ് ചെയ്ത പാർസറിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, അത് മറ്റെല്ലാ കാര്യങ്ങളിലും ചെയ്യും
ആരോഗ്യവാനായിരിക്കുക.

സാധ്യത അനന്തമായ ഇടത്തെ ആവർത്തനം in ഭരണം 'foo'
'ഫൂ' എന്ന നിയമത്തിൽ നിന്ന് നയിക്കുന്ന വ്യാകരണത്തിലൂടെ ഒരു പാതയെങ്കിലും നിലവിലുണ്ട്.
ഇൻപുട്ടൊന്നും ഉപയോഗിക്കാതെ അതേ നിയമത്തിലേക്ക് മടങ്ങുക.

ഇടത് ആവർത്തനം, പ്രത്യേകിച്ച് സ്റ്റാൻഡേർഡ് ഡോക്യുമെന്റുകളിൽ കാണപ്പെടുന്നത്, പലപ്പോഴും 'ഡയറക്ട്' ആണ്
നിസ്സാരമായ ആവർത്തനത്തെ സൂചിപ്പിക്കുന്നു.

# (6.7.6)
direct-abstract-declarator =
LPAREN അമൂർത്ത-ഡിക്ലറേറ്റർ RPAREN
| നേരിട്ടുള്ള-അമൂർത്തമായ-ഡിക്ലറേറ്റർ? LBRACKET assign-expr? ആർബ്രാക്കറ്റ്
| നേരിട്ടുള്ള-അമൂർത്തമായ-ഡിക്ലറേറ്റർ? എൽബ്രാക്കറ്റ് സ്റ്റാർ ർബ്രാക്കറ്റ്
| നേരിട്ടുള്ള-അമൂർത്തമായ-ഡിക്ലറേറ്റർ? LPAREN പാരാം-ടൈപ്പ്-ലിസ്റ്റ്? RPAREN

ഇനിപ്പറയുന്ന പാറ്റേണിന്റെ ഭാഗങ്ങൾ പരിവർത്തനം ചെയ്യുന്നതിലൂടെ ആവർത്തനത്തെ എളുപ്പത്തിൽ ഇല്ലാതാക്കാൻ കഴിയും
ആവർത്തിക്കാവുന്ന പ്രത്യയത്തിലേക്കുള്ള ആവർത്തനം.

# (6.7.6)
direct-abstract-declarator =
നേരിട്ടുള്ള-അമൂർത്തമായ-ഡിക്ലറേറ്റർ-ഹെഡ്?
നേരിട്ടുള്ള-അമൂർത്തമായ-ഡിക്ലറേറ്റർ-ടെയിൽ*

direct-abstract-declarator-head =
LPAREN അമൂർത്ത-ഡിക്ലറേറ്റർ RPAREN

direct-abstract-declarator-tail =
LBRACKET assign-expr? ആർബ്രാക്കറ്റ്
| എൽബ്രാക്കറ്റ് സ്റ്റാർ ർബ്രാക്കറ്റ്
| LPAREN പാരാം-ടൈപ്പ്-ലിസ്റ്റ്? RPAREN

മുന്നറിയിപ്പ്

ശൂന്യമായ ഇൻപുട്ട് സ്വീകരിക്കുന്ന ഒരു പാഴ്സർ എല്ലായിപ്പോഴും വിജയിക്കുക. ഇനിപ്പറയുന്ന ഉദാഹരണം പരിഗണിക്കുക,
PEG-അടിസ്ഥാനത്തിലുള്ള പാഴ്സർ എഴുതാനുള്ള ആദ്യ ശ്രമത്തിന്റെ വിഭിന്നമല്ല:

പ്രോഗ്രാം = എക്സ്പ്രഷൻ*
ആവിഷ്കാരം = "എന്തായാലും"
%%
int പ്രധാന () {
അതേസമയം (yyparse())
ഇടുന്നു ("വിജയം!");
തിരികെ വരുക;
}

stdin-ൽ എന്ത് (എന്തെങ്കിലും ഉണ്ടെങ്കിൽ) ഇൻപുട്ട് നൽകിയാലും ഈ പ്രോഗ്രാം എന്നെന്നേക്കുമായി ലൂപ്പ് ചെയ്യുന്നു. പലതും
പരിഹാരങ്ങൾ സാധ്യമാണ്, പാഴ്സർ എപ്പോഴും ചിലത് ഉപയോഗിക്കണമെന്ന് നിർബന്ധിക്കുന്നതാണ് ഏറ്റവും എളുപ്പമുള്ളത്
ശൂന്യമല്ലാത്ത ഇൻപുട്ട്. ആദ്യ വരി ഇതിലേക്ക് മാറ്റുന്നു

പ്രോഗ്രാം = എക്സ്പ്രഷൻ+

ഇത് നിറവേറ്റുന്നു. പാഴ്‌സർ മുഴുവൻ ഇൻപുട്ടും ഉപയോഗിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നുവെങ്കിൽ, വ്യക്തമായി
എൻഡ്-ഓഫ്-ഫയൽ ആവശ്യപ്പെടുന്നതും വളരെ ശുപാർശ ചെയ്യപ്പെടുന്നു:

പ്രോഗ്രാം = എക്സ്പ്രഷൻ+!.

ഇത് പ്രവർത്തിക്കുന്നു, കാരണം പാഴ്സർ ഏതെങ്കിലും പ്രതീകവുമായി പൊരുത്തപ്പെടുന്നില്ല ("!" പ്രവചിക്കുക).
("." എക്സ്പ്രഷൻ) ഇൻപുട്ടിന്റെ അവസാനത്തിനപ്പുറം വായിക്കാൻ ശ്രമിക്കുമ്പോൾ.

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