yaccposix - Online sa Cloud

PROGRAMA:

NAME

yacc - isa pang compiler compiler (Pag-unlad)

SINOPSIS

yacc [−dltv] [−b file_prefix] [−p sym_prefix] gramatika

DESCRIPTION

Ang yacc dapat basahin ng utility ang isang paglalarawan ng isang gramatika na walang konteksto sa gramatika at isulat ang C
source code, alinsunod sa ISO C standard, sa isang code file, at opsyonal na header
impormasyon sa isang header file, sa kasalukuyang direktoryo. Ang nabuong source code ay dapat
hindi nakadepende sa anumang hindi natukoy, hindi natukoy, o natukoy na pag-uugali sa pagpapatupad, maliban sa
mga kaso kung saan ito ay direktang kinopya mula sa ibinigay na grammar, o sa mga kaso na
dokumentado ng pagpapatupad. Dapat tukuyin ng C code ang isang function at mga kaugnay na gawain
at mga macro para sa isang automat na nagsasagawa ng parsing algorithm na nakakatugon sa mga kinakailangan sa
Algorithm.

Ang anyo at kahulugan ng grammar ay inilarawan sa seksyong EXTENDED DESCRIPTION.

Ang C source code at header file ay dapat gawin sa isang form na angkop bilang input para sa C
compiler (tingnan c99).

Opsyon

Ang yacc ang utility ay dapat umayon sa Base Definition volume ng POSIX.1–2008, seksyon
12.2, Gamit palaugnayan Mga Alituntunin, maliban sa Patnubay 9.

Ang mga sumusunod na opsyon ay dapat suportahan:

−b file_prefix
paggamit file_prefix sa halip ng y bilang prefix para sa lahat ng output filename. Ang code
file y.tab.c, ang header file y.tab.h (nalikha noong −d ay tinukoy), at ang
file ng paglalarawan y.output (nalikha noong −v ay tinukoy), ay dapat baguhin sa
file_prefix.tab.c, file_prefix.tab.h, at file_prefix.output, Ayon sa pagkakabanggit.

−d Isulat ang header file; bilang default, ang code file lamang ang nakasulat. Ang # tukuyin
iniuugnay ng mga pahayag ang mga token code na itinalaga ni yacc na idineklara ng gumagamit
mga pangalan ng token. Nagbibigay-daan ito sa mga source file maliban sa y.tab.c para ma-access ang token
mga code.

−l Gumawa ng code file na walang anumang laman #linya mga konstruksyon. Kung ang pagpipiliang ito
ay wala, hindi natukoy kung naglalaman ang code file o header file
#linya mga direktiba. Ito ay dapat lamang gamitin pagkatapos ng gramatika at ang nauugnay
ganap na na-debug ang mga aksyon.

−p sym_prefix
paggamit sym_prefix sa halip ng yy bilang prefix para sa lahat ng panlabas na pangalan na ginawa ng
yacc. Kasama sa mga pangalang apektado ang mga function yparse🇧🇷 yylex(), at
yyerror(), at ang mga variable yylval, yychar, at yydebug. (Sa natitirang bahagi ng
sa seksyong ito, ang anim na simbolo na binanggit ay isinangguni gamit ang kanilang mga default na pangalan
only as a nottional convenience.) Ang mga lokal na pangalan ay maaari ding maapektuhan ng −p
opsyon; gayunpaman, ang −p hindi makakaapekto ang opsyon # tukuyin mga simbolo na nabuo ng
yacc.

−t Baguhin ang mga conditional compilation directive para payagan ang compilation ng debugging
code sa code file. Ang mga pahayag sa pag-debug ng runtime ay dapat palaging nasa loob
ang code file, ngunit bilang default, pinipigilan ng mga conditional compilation directive ang mga ito
compilation.

−v Sumulat ng isang file na naglalaman ng isang paglalarawan ng parser at isang ulat ng mga salungatan
nabuo ng mga kalabuan sa gramatika.

MGA OPERAND

Ang sumusunod na operand ay kinakailangan:

gramatika Isang pathname ng isang file na naglalaman ng mga tagubilin, pagkatapos ay tinatawag na gramatika, Para sa
na isang parser ay gagawin. Ang format para sa grammar ay inilarawan sa
Seksyon ng EXTENDED DESCRIPTION.

STDIN

Hindi ginagamit.

INPUT MGA FILE

Ang file gramatika ay isang text file na naka-format gaya ng tinukoy sa EXTENDED DESCRIPTION
seksyon.

Kapaligiran MGA VARIABLE

Ang mga sumusunod na variable ng kapaligiran ay dapat makaapekto sa pagpapatupad ng yacc:

WIKA Magbigay ng default na halaga para sa mga variable ng internationalization na hindi nakatakda o
wala. (Tingnan ang dami ng Base Definition ng POSIX.1–2008, seksyon 8.2,
internationalization Variable para sa pangunguna sa internasyonalisasyon
mga variable na ginagamit upang matukoy ang mga halaga ng mga lokal na kategorya.)

LC_ALL Kung nakatakda sa isang walang laman na halaga ng string, i-override ang mga halaga ng lahat ng iba pa
mga variable ng internasyonalisasyon.

LC_CTYPE Tukuyin ang lokal para sa interpretasyon ng mga pagkakasunud-sunod ng mga byte ng data ng teksto
bilang mga character (halimbawa, single-byte kumpara sa multi-byte na character sa
argumento at input file).

LC_MESSAGES
Tukuyin ang lokal na dapat gamitin upang makaapekto sa format at mga nilalaman ng
mga mensaheng diagnostic na nakasulat sa karaniwang error.

NLSPATH Tukuyin ang lokasyon ng mga katalogo ng mensahe para sa pagproseso ng LC_MESSAGES.

Ang WIKA at LC_* ang mga variable ay nakakaapekto sa pagpapatupad ng yacc utility gaya ng nakasaad. Ang pangunahin()
function na tinukoy sa Yacc Aklatan tatawag:

setlocale(LC_ALL, "")

at sa gayon ang programang nabuo ng yacc maaapektuhan din ng mga nilalaman ng mga ito
mga variable sa runtime.

ASYNCHRONOUS KAGANAPAN

Default.

STDOUT

Hindi ginagamit.

STDERR

Kung ang shift/bawasan o bawasan/bawasan ang mga salungatan ay nakita sa gramatika, yacc magsulat ng a
iulat ang mga salungat na iyon sa karaniwang error sa isang hindi natukoy na format.

Ang karaniwang error ay dapat ding gamitin para sa mga diagnostic na mensahe.

oUTPUT MGA FILE

Ang code file, ang header file, at ang description file ay mga text file. Lahat ay
inilalarawan sa mga sumusunod na seksyon.

kodigo talaksan
Ang file na ito ay dapat maglaman ng C source code para sa yparse() function. Ito ay maglalaman
code para sa iba't ibang semantic na aksyon na may macro substitution na ginawa sa kanila bilang
inilarawan sa seksyong EXTENDED DESCRIPTION. Dapat din itong maglaman ng kopya ng # tukuyin
mga pahayag sa header file. Kung ang %unyon deklarasyon ang ginagamit, ang deklarasyon para sa
Ang YYSTYPE ay dapat ding isama sa file na ito.

Ulo talaksan
Ang file ng header ay dapat maglaman # tukuyin mga pahayag na nag-uugnay ng mga token number sa
mga pangalan ng token. Nagbibigay-daan ito sa mga source file maliban sa code file na ma-access ang mga token code.
Kung ang isang %unyon deklarasyon ang ginagamit, ang deklarasyon para sa YYSTYPE at an panlabas YYSTYPE yylval
deklarasyon ay dapat ding isama sa file na ito.

paglalarawan talaksan
Ang file ng paglalarawan ay dapat na isang text file na naglalaman ng isang paglalarawan ng makina ng estado
naaayon sa parser, gamit ang isang hindi natukoy na format. Mga limitasyon para sa panloob na mga talahanayan (tingnan
Mga Limitasyon) ay dapat ding iulat, sa paraang tinukoy sa pagpapatupad. (Ang ilang mga pagpapatupad
maaaring gumamit ng mga dynamic na diskarte sa paglalaan at walang tiyak na mga halaga ng limitasyon na iuulat.)

LALAKI DESCRIPTION

Ang yacc tumatanggap ang command ng isang wika na ginagamit upang tukuyin ang isang grammar para sa isang target na wika
na mai-parse ng mga talahanayan at code na nabuo ni yacc. Ang wikang tinanggap ni yacc bilang isang
Ang gramatika para sa target na wika ay inilalarawan sa ibaba gamit ang yacc wika ng input mismo.

Ang input gramatika kabilang ang mga panuntunang naglalarawan sa istruktura ng input ng target na wika at
code na gagamitin kapag kinikilala ang mga panuntunang ito upang magbigay ng nauugnay na semantiko
aksyon. Ang code na isasagawa ay lilitaw bilang mga katawan ng teksto na nilalayong maging C-
code ng wika. Ang mga katawan ng tekstong ito ay hindi dapat maglaman ng mga trigraph sa C-language. Ang C-wika
ang mga inklusyon ay ipinapalagay na bumubuo ng isang tamang function kapag naproseso ng yacc sa output nito
mga file. Ang code na kasama sa paraang ito ay dapat isakatuparan sa panahon ng pagkilala sa
target na wika.

Dahil sa isang grammar, ang yacc ang utility ay bumubuo ng mga file na inilarawan sa OUTPUT FILES
seksyon. Maaaring i-compile at i-link ang code file gamit ang c99. Kung ang deklarasyon at
Ang mga seksyon ng program ng grammar file ay hindi kasama ang mga kahulugan ng pangunahin🇧🇷 yylex(), at
yyerror(), ang pinagsama-samang output ay nangangailangan ng pag-link sa mga panlabas na ibinigay na bersyon ng mga iyon
mga function. Mga default na bersyon ng pangunahin() at yyerror() ay ibinibigay sa yacc aklatan at
maaaring maiugnay sa pamamagitan ng paggamit ng −l y operand sa c99. ang yacc hindi kailangan ng mga interface ng library
suporta sa mga interface sa iba kaysa sa default yy prefix ng simbolo. Nagbibigay ang application
ang function ng lexical analyzer, yylex(); ang lex ang utility ay partikular na idinisenyo upang
bumuo ng ganoong kalakaran.

input Wika
Dapat tiyakin ng aplikasyon na ang bawat file ng detalye ay binubuo ng tatlong seksyon sa
order: deklarasyon, gramatika patakaran, at mga programa, pinaghihiwalay ng doble
mga karakter ("%%"). Maaaring walang laman ang mga seksyon ng mga deklarasyon at programa. Kung ang huli ay
walang laman, ang nauna "%%" maaaring tanggalin ang markang naghihiwalay dito sa seksyon ng mga panuntunan.

Ang input ay libreng form na text na sumusunod sa istruktura ng grammar na tinukoy sa ibaba.

Leksikal kaayusan of ang Gramatika
Ang , , at ang karakter ay hindi papansinin, maliban na ang
dapat tiyakin ng aplikasyon na hindi ito makikita sa mga pangalan o nakareserbang maraming karakter
mga simbolo. Ang mga komento ay dapat ilakip sa "/* ... */", at maaaring lumitaw saanman ang isang pangalan
wasto

Ang mga pangalan ay may di-makatwirang haba, na binubuo ng mga titik, tuldok ('.'), salungguhit ('_'), At
mga hindi paunang digit. Magkaiba ang malaki at maliit na titik. Alinsunod sa mga aplikasyon
hindi gagamit ng mga pangalan na nagsisimula sa yy or YY dahil ang yacc gumagamit ang parser ng mga ganoong pangalan. Marami sa
lumilitaw ang mga pangalan sa huling output ng yacc, at sa gayon sila ay dapat piliin na umayon
na may anumang karagdagang mga panuntunan na nilikha ng C compiler na gagamitin. Sa partikular, lumilitaw sila
in # tukuyin mga pahayag.

Ang literal ay dapat na binubuo ng isang character na nakapaloob sa mga single-quote na character. Lahat ng
ang mga escape sequence na sinusuportahan para sa character constants ng ISO C standard ay dapat
suportado ng yacc.

Ang kaugnayan sa lexical analyzer ay tinalakay nang detalyado sa ibaba.

Dapat tiyakin ng aplikasyon na ang karakter na NUL ay hindi ginagamit sa mga tuntunin sa gramatika o
mga literal.

Pahayag seksyon
Ang seksyon ng mga deklarasyon ay ginagamit upang tukuyin ang mga simbolo na ginamit upang tukuyin ang target na wika
at ang kanilang relasyon sa isa't isa. Sa partikular, marami sa karagdagang impormasyon
kinakailangan upang malutas ang mga kalabuan sa gramatika na walang konteksto para sa target na wika ay
na ibinigay dito.

Karaniwan yacc nagtatalaga ng kaugnayan sa pagitan ng mga simbolikong pangalan na nabuo nito at ng mga ito
pinagbabatayan na halaga ng numero. Ginagawang posible ng seksyon ng mga deklarasyon na kontrolin ang
pagtatalaga ng mga halagang ito.

Posible ring panatilihin ang semantic na impormasyon na nauugnay sa mga token na kasalukuyang naka-on
ang parse stack sa isang C-language na tinukoy ng user unyon, kung ang mga miyembro ng unyon ay
nauugnay sa iba't ibang pangalan sa gramatika. Ang seksyon ng mga deklarasyon ay nagbibigay para sa
ito rin.

Ang unang pangkat ng mga deklarador sa ibaba ay kumukuha ng listahan ng mga pangalan bilang mga argumento. Ang listahan na iyon ay maaari
opsyonal na unahan ng pangalan ng isang miyembro ng unyon ng C (tinatawag na a mga tag sa ibaba) na lumilitaw
sa loob ng '<' at '>'. (Bilang pagbubukod sa mga typographical convention ng iba pa nito
dami ng POSIX.1-2008, sa kasong itomga tag> ay hindi kumakatawan sa isang metavariable, ngunit ang
literal na anggulong bracket na mga karakter na nakapalibot sa isang simbolo.) Ang paggamit ng mga tag tumutukoy na ang
Ang mga token na pinangalanan sa linyang ito ay kaparehong uri ng C gaya ng tinutukoy ng miyembro ng unyon
mga tag. Ito ay tinalakay nang mas detalyado sa ibaba.

Para sa mga listahang ginamit upang tukuyin ang mga token, ang unang hitsura ng isang ibinigay na token ay maaaring sundan ng
isang positibong integer (bilang isang string ng mga decimal na digit). Kung ito ay tapos na, ang pinagbabatayan na halaga
itinalaga dito para sa mga layuning leksikal ay dapat kunin na bilang na iyon.

Ang mga sumusunod ay nagpapahayag pangalan upang maging isang tanda:

%token [<mga tag>] pangalan [numero] [pangalan [numero]]...

If mga tag ay naroroon, ang uri ng C para sa lahat ng mga token sa linyang ito ay dapat ideklara bilang ang uri
sinangguni ng mga tag. Kung positibong integer, numero, sumusunod sa a pangalan, ang halagang iyon ay magiging
itinalaga sa token.

Ang mga sumusunod ay nagpapahayag pangalan upang maging isang token, at nagtatalaga ng precedence dito:

%kaliwa [<mga tag>] pangalan [numero] [pangalan [numero]]...
%tama [<mga tag>] pangalan [numero] [pangalan [numero]]...

Ang isa o higit pang mga linya, bawat isa ay nagsisimula sa isa sa mga simbolo na ito, ay maaaring lumitaw sa seksyong ito.
Ang lahat ng mga token sa parehong linya ay may parehong antas ng precedence at pagkakaugnay; ang mga linya
ay sa pagkakasunud-sunod ng pagtaas ng precedence o nagbubuklod na lakas. %kaliwa nagsasaad na ang
ang mga operator sa linyang iyon ay naiwang nag-uugnay, at %tama parehong nagsasaad ng tama
associative operator. Kung mga tag ay naroroon, dapat itong magpahayag ng isang uri ng C para sa pangalans tulad ng inilarawan
para %token.

Ang mga sumusunod ay nagpapahayag pangalan upang maging isang token, at nagpapahiwatig na hindi ito magagamit
kaugnay:

%nonassoc [<mga tag>] pangalan [numero] [pangalan [numero]]...

Kung ang parser ay nakatagpo ng nauugnay na paggamit ng token na ito, nag-uulat ito ng isang error. Kung mga tag is
kasalukuyan, dapat itong magdeklara ng isang uri ng C para sa pangalans tulad ng inilarawan para sa %token.

Ang mga sumusunod ay nagpapahayag na miyembro ng unyon pangalans ay hindi mga terminal, at sa gayon ito ay kinakailangan
para magkaroon ng mga tag field sa simula nito:

%type <mga tag> pangalan...

Dahil nakikitungo ito sa mga hindi terminal lamang, ang pagtatalaga ng token number o paggamit ng literal ay
ipinagbabawal din. Kung ang construct na ito ay naroroon, yacc dapat magsagawa ng pagsuri ng uri; kung ito
construct ay hindi naroroon, ang parse stack ay dapat hawakan lamang ang int uri.

Bawat pangalan na ginamit sa gramatika hindi tinukoy ng a %token, %kaliwa, %tama, O %nonassoc
ipinapalagay na ang deklarasyon ay kumakatawan sa isang di-terminal na simbolo. Ang yacc mag-uulat ang utility
isang error para sa anumang simbolo na hindi terminal na hindi lumalabas sa kaliwang bahagi ng kahit isa
tuntunin sa gramatika.

Kapag ang uri, precedence, o numero ng token ng isang pangalan ay tinukoy, hindi ito dapat
nagbago. Kung ang unang deklarasyon ng isang token ay hindi nagtatalaga ng numero ng token, yacc Dapat
magtalaga ng numero ng token. Kapag nagawa na ang pagtatalagang ito, hindi na babaguhin ang numero ng token
sa pamamagitan ng tahasang pagtatalaga.

Ang mga sumusunod na declarator ay hindi sumusunod sa nakaraang pattern.

Ang sumusunod ay nagdedeklara ng hindi terminal pangalan upang maging simula simbolo, na kumakatawan sa
pinakamalaki, pinaka-pangkalahatang istruktura na inilarawan ng mga tuntunin sa gramatika:

%simula pangalan

Bilang default, ito ang kaliwang bahagi ng unang tuntunin sa grammar; ang default na ito ay maaaring
na-override sa deklarasyong ito.

Ang mga sumusunod ay nagpapahayag ng yacc value stack upang maging isang unyon ng iba't ibang uri ng mga value
ninanais.

%unyon { katawan of unyon (in C)}

Ang katawan ng unyon ay hindi dapat maglaman ng hindi balanseng mga curly brace na preprocessing token.

Bilang default, ang mga halaga na ibinalik ng mga aksyon (tingnan sa ibaba) at ang lexical analyzer ay dapat
ng uri int. ang yacc Sinusubaybayan ng utility ang mga uri, at dapat itong magpasok ng katumbas
mga pangalan ng miyembro ng unyon upang maisagawa ang mahigpit na pagsusuri ng uri ng resultang parser.

Bilang kahalili, ibinigay na kahit isamga tag> construct ay ginagamit, ang unyon ay maaaring ideklara
sa isang header file (na isasama sa seksyon ng mga deklarasyon sa pamamagitan ng paggamit ng a # isama
bumuo sa loob %{ at %}), at a typedef ginamit upang tukuyin ang simbolo na YYSTYPE na kinakatawan
ang unyon na ito. Ang epekto ng %unyon ay upang ibigay ang deklarasyon ng YYSTYPE nang direkta mula sa
ang yacc input.

Maaaring lumabas ang mga deklarasyon at kahulugan ng C-language sa seksyon ng mga deklarasyon, na nakapaloob
sa pamamagitan ng mga sumusunod na marka:

%{ ... %}

Ang mga pahayag na ito ay dapat makopya sa code file, at magkaroon ng pandaigdigang saklaw sa loob nito
na magagamit ang mga ito sa mga tuntunin at mga seksyon ng programa. Ang mga pahayag ay hindi dapat maglaman
"%}" sa labas ng komento, string literal, o multi-character constant.

Dapat tiyakin ng aplikasyon na ang seksyon ng mga deklarasyon ay winakasan ng token %%.

Gramatika Batas in yacc
Tinutukoy ng seksyon ng mga panuntunan ang grammar na walang konteksto na tatanggapin ng function yacc
bumubuo, at nag-uugnay sa mga panuntunang iyon ng mga pagkilos sa C-language at karagdagang precedence
impormasyon. Ang grammar ay inilarawan sa ibaba, at isang pormal na kahulugan ang sumusunod.

Ang seksyon ng mga panuntunan ay binubuo ng isa o higit pang mga tuntunin sa gramatika. Ang isang tuntunin sa gramatika ay may anyo:

A : BODY ;

Ang simbolo A kumakatawan sa isang pangalan na hindi terminal, at BODY kumakatawan sa isang sequence ng zero o
mas marami pang pangalans, literals, at semantiko aksyons na maaaring sundan ng opsyonal
karapatan sa pangunguna mamunos. Ang mga pangalan at literal lamang ang lumahok sa pagbuo ng
gramatika; ang mga semantikong aksyon at mga tuntunin sa pag-uuna ay ginagamit sa ibang mga paraan. Ang at
ang ay yacc bantas. Kung mayroong ilang magkakasunod na tuntunin sa gramatika na may
ang parehong kaliwang bahagi, ang ('|') ay maaaring gamitin upang maiwasan ang muling pagsulat ng
kaliwang bahagi; sa kasong ito ang lalabas lamang pagkatapos ng huling panuntunan. Ang katawan
Ang bahagi ay maaaring walang laman (o walang laman ng mga pangalan at literal) upang ipahiwatig na ang non-terminal
ang simbolo ay tumutugma sa walang laman na string.

Ang yacc Ang utility ay nagtatalaga ng natatanging numero sa bawat panuntunan. Mga panuntunan gamit ang vertical bar
ang notasyon ay mga natatanging tuntunin. Ang numerong itinalaga sa panuntunan ay lumalabas sa paglalarawan
file.

Ang mga elementong binubuo ng KATAWAN ay:

pangalan, literal
Ang mga ito ay bumubuo ng mga tuntunin ng gramatika: pangalan ay alinman sa a token o isang hindi terminal;
literal nakatayo para sa sarili nito (mas mababa ang leksikal na kinakailangang mga panipi).

semantiko aksyon
Sa bawat tuntunin ng grammar, maaaring iugnay ng user ang mga aksyon na isasagawa sa bawat oras
ang panuntunan ay kinikilala sa proseso ng pag-input. (Tandaan na ang salitang ``aksyon'' ay maaaring
sumangguni din sa mga aksyon ng parser—shift, reduce, at iba pa.)

Ang mga pagkilos na ito ay maaaring magbalik ng mga halaga at maaaring makuha ang mga halaga na ibinalik ng nakaraan
mga aksyon. Ang mga halagang ito ay pinananatili sa mga bagay na may uri ng YYSTYPE (tingnan %unyon). Ang
ang halaga ng resulta ng aksyon ay dapat itago sa parse stack gamit ang kaliwang kamay
bahagi ng panuntunan, na ma-access ng iba pang mga pagbawas bilang bahagi ng kanilang kanang kamay
gilid. Sa pamamagitan ng paggamit ngmga tag> impormasyong ibinigay sa seksyon ng mga deklarasyon, ang
code na nabuo ng yacc maaaring mahigpit na i-type check at naglalaman ng arbitrary
impormasyon. Bilang karagdagan, ang lexical analyzer ay maaaring magbigay ng parehong mga uri ng
mga halaga para sa mga token, kung ninanais.

Ang isang aksyon ay isang arbitrary na pahayag ng C at dahil dito ay maaaring gumawa ng input o output, call
mga subprogram, at baguhin ang mga panlabas na variable. Ang aksyon ay isa o higit pang C na pahayag
nakapaloob sa mga kulot na braces '{' at '}'. Ang mga pahayag ay hindi dapat maglaman
hindi balanseng curly brace preprocessing token.

Maaaring gamitin ang ilang pseudo-variable sa pagkilos. Ito ay mga macro para sa pag-access
sa mga istruktura ng data na kilala sa loob yacc.

$$ Ang halaga ng aksyon ay maaaring itakda sa pamamagitan ng pagtatalaga nito sa $$. Kung type
ang pagsuri ay pinagana at ang uri ng halaga na itatalaga ay hindi maaaring
natukoy, maaaring makabuo ng mensaheng diagnostic.

$numero Ito ay tumutukoy sa halagang ibinalik ng sangkap na tinukoy ng
token numero sa kanang bahagi ng isang panuntunan, nagbabasa mula kaliwa hanggang kanan;
numero maaaring zero o negatibo. Kung numero ay zero o negatibo, ito
ay tumutukoy sa data na nauugnay sa pangalan sa stack ng parser
nauuna sa pinakakaliwang simbolo ng kasalukuyang panuntunan. (Yan ay, "$0"
ay tumutukoy sa pangalang nauuna kaagad sa pinakakaliwang pangalan sa
kasalukuyang panuntunan na makikita sa stack ng parser at "$−1" tumutukoy sa
simbolo sa nito kaliwa.) Kung numero ay tumutukoy sa isang elementong lampas sa kasalukuyang
punto sa panuntunan, o lampas sa ilalim ng stack, ang resulta ay
hindi natukoy. Kung ang pagsuri ng uri ay pinagana at ang uri ng magiging halaga
hindi matukoy ang itinalaga, maaaring makabuo ng mensaheng diagnostic.

$<mga tag>numero
Ang mga ito ay eksaktong tumutugma sa mga katumbas na simbolo nang walang mga tag
pagsasama, ngunit payagan ang mahigpit na pagsusuri ng uri (at pigilan ang hindi gustong
uri ng mga conversion). Ang epekto ay ang macro ay pinalawak upang magamit mga tag
upang pumili ng elemento mula sa YYSTYPE unyon (gamit ang dataname.tag).
Ito ay partikular na kapaki-pakinabang kung numero ay hindi positibo.

$<mga tag>$ Ito ay nagpapataw sa sanggunian ng uri ng miyembro ng unyon na tinutukoy
by mga tag. Naaangkop ang construction na ito kapag may reference sa kaliwa
Ang halaga ng konteksto ay nangyayari sa grammar, at nagbibigay yacc na may paraan
para sa pagpili ng isang uri.

Maaaring maganap ang mga aksyon kahit saan sa isang panuntunan (hindi lamang sa dulo); maaaring ma-access ang isang aksyon
mga value na ibinalik sa pamamagitan ng mga aksyon sa kaliwa nito, at maaaring maging ang halaga na ibinabalik nito
na-access ng mga aksyon sa kanan nito. Isang pagkilos na lumalabas sa gitna ng isang panuntunan
ay katumbas ng pagpapalit ng aksyon ng isang bagong hindi-terminal na simbolo at
pagdaragdag ng walang laman na panuntunan na may simbolong hindi terminal na iyon sa kaliwang bahagi. Ang
Ang semantikong aksyon na nauugnay sa bagong panuntunan ay dapat na katumbas ng orihinal
aksyon. Ang paggamit ng mga aksyon sa loob ng mga panuntunan ay maaaring magpasok ng mga salungatan na hindi
kung hindi man ay umiiral.

Bilang default, ang halaga ng isang panuntunan ay ang halaga ng unang elemento dito.
Kung ang unang elemento ay walang uri (lalo na sa kaso ng a
literal) at ang pagsuri ng uri ay na-on ni %type, isang mensahe ng error ang magreresulta.

karapatan sa pangunguna
Ang keyword %prec maaaring gamitin upang baguhin ang antas ng precedence na nauugnay sa a
partikular na tuntunin sa gramatika. Ang mga halimbawa nito ay sa mga kaso kung saan ang unary at binary
operator ay may parehong simbolikong representasyon, ngunit kailangang bigyan ng iba
nauuna, o kung saan ang paghawak ng isang hindi tiyak na konstruksyon na if-else
kailangan. Ang nakalaan na simbolo %prec maaaring lumitaw kaagad pagkatapos ng katawan ng
ang tuntunin sa gramatika at maaaring sundan ng isang pangalan ng token o isang literal. Ito ay dapat
maging sanhi ng pagiging nangunguna sa tuntunin ng gramatika sa sumusunod na token
pangalan o literal. Maaaring sundin ang aksyon para sa panuntunan sa kabuuan %prec.

Kung susunod ang isang seksyon ng programa, dapat tiyakin ng aplikasyon na ang mga tuntunin sa gramatika ay
winakasan ng %%.

Programa seksyon
Ang mga programa maaaring isama ng seksyon ang kahulugan ng lexical analyzer yylex(), at anuman
iba pang mga pag-andar; halimbawa, ang mga ginamit sa mga aksyon na tinukoy sa mga tuntunin sa grammar. Ito
ay hindi tinukoy kung ang seksyon ng mga programa ay nauuna o sumusunod sa mga semantic na aksyon sa
ang output file; samakatuwid, kung ang application ay naglalaman ng anumang mga kahulugan ng macro at
mga deklarasyon na nilalayong ilapat sa code sa mga aksyong semantiko, dapat itong ilagay ang mga ito
sa loob ng "%{ ... %}" sa seksyon ng mga deklarasyon.

input Gramatika
Ang sumusunod na input sa yacc nagbubunga ng parser para sa input sa yacc. Ang pormal na syntax na ito
nangunguna kaysa sa naunang paglalarawan ng syntax ng teksto.

Ang istrukturang leksikal ay binibigyang kahulugan nang hindi gaanong tumpak; Leksikal kaayusan of ang Gramatika tumutukoy
karamihan sa mga termino. Ang pagsusulatan sa pagitan ng mga nakaraang termino at mga token sa ibaba ay bilang
Sumusunod.

IDENTIFIER Ito ay tumutugma sa konsepto ng pangalan, ibinigay dati. Kasama rin dito
literal tulad ng tinukoy dati.

C_IDENTIFIER
Ito ay isang pangalan, at bukod pa rito ay kilala na sinusundan ng a . A
hindi kayang ibigay ng literal ang token na ito.

NUMBER Isang string ng mga digit (isang hindi negatibong decimal integer).

TYPE, Kaliwa, MARKA, LCURL, RCURL
Ang mga ito ay direktang tumutugma sa %type, %kaliwa, %%, %{, at %}.

{ ... } Ito ay nagpapahiwatig ng C-language source code, na may posibleng pagsasama ng '$'
macros gaya ng tinalakay dati.

/* Gramatika para ang input sa yacc. */
/* Basic mga entry. */
/* Ang sumusunod ay tinanggap by ang leksikal tagapag-aral */

%token IDENTIFIER /* May kasamang mga identifier at literal */
%token C_IDENTIFIER /* identifier (ngunit hindi literal)
sinusundan ng isang :. */
%token NUMBER /* [0-9][0-9]* */

/* Mga reserbang salita : %type=>TYPE %left=>LEFT, at iba pa */

%token KALIWA KANAN NONASSOC TOKEN PREC TYPE START UNION

%token MARK /* Ang %% mark. */
%token LCURL /* Ang %{ mark. */
%token RCURL /* Ang markang %}. */

/* Ang mga literal na 8-bit na character ay nakatayo para sa kanilang sarili; */
Ang mga token /* ay kailangang tukuyin para sa mga multi-byte na character. */

%start spec

%%

spec : defs MARK rules tail
;
buntot: MARK
{
/* Sa pagkilos na ito, i-set up ang natitirang bahagi ng file. */
}
| /* Walang laman; ang pangalawang MARKAHAN ay opsyonal. */
;
defs : /* Walang laman. */
| def
;
def : MAGSIMULA NG IDENTIFIER
| UNYON
{
/* Kopyahin ang kahulugan ng unyon sa output. */
}
| LCURL
{
/* Kopyahin ang C code sa output file. */
}
RCURL
| rword tag nlist
;
rword : TOKEN
| KALIWA
| TAMA
| NONASSOC
| URI
;
tag : /* Walang laman: opsyonal ang ID ng tag ng unyon. */
| '<' IDENTIFIER '>'
;
nlist : nmno
| nlist nmno
;
nmno : IDENTIFIER /* Tandaan: literal na invalid na may % type. */
| IDENTIFIER NUMBER /* Tandaan: di-wasto sa % uri. */
;

/* Seksyon ng panuntunan */

panuntunan : C_IDENTIFIER rbody prec
| tuntuning tuntunin
;
panuntunan : C_IDENTIFIER rbody prec
| '|' rbody prec
;
rbody : /* walang laman */
| rbody IDENTIFIER
| kilos ng katawan
;
kumilos: '{'
{
/* Kopyahin ang aksyon, isalin ang $$, at iba pa. */
}
'}'
;
prec : /* Walang laman */
| PREC IDENTIFIER
| PREC IDENTIFIER act
| prec ';'
;

Pula ang mga salungatan
Ang parser na ginawa para sa isang input grammar ay maaaring maglaman ng mga estado kung saan nagaganap ang mga salungatan. Ang
nagaganap ang mga salungatan dahil ang gramatika ay hindi LALR(1). Palaging naglalaman ang isang hindi tiyak na gramatika
kahit isa LALR(1) salungatan. Ang yacc dapat lutasin ng utility ang lahat ng mga salungatan, gamit ang alinman
mga default na panuntunan o mga panuntunan sa pangunguna na tinukoy ng user.

Ang mga salungatan ay maaaring ilipat/bawasan ang mga salungatan o bawasan/bawasan ang mga salungatan. Isang shift/pagbawas
ang salungatan ay kung saan, para sa isang partikular na estado at simbolo ng lookahead, parehong shift action at a
bawasan ang pagkilos ay posible. Ang bawasan/bawasan ang salungatan ay kung saan, para sa isang partikular na estado at
lookahead na simbolo, ang mga pagbawas ng dalawang magkaibang panuntunan ay posible.

Inilalarawan ng mga panuntunan sa ibaba kung paano tukuyin kung anong mga aksyon ang gagawin kapag may naganap na salungatan. Hindi
lahat ng shift/reduce conflicts ay matagumpay na malulutas sa ganitong paraan dahil maaaring ang conflict
ay dahil sa isang bagay maliban sa kalabuan, kaya maaaring maging sanhi ng hindi maingat na paggamit ng mga pasilidad na ito
ang wikang tinanggap ng parser ay ibang-iba sa nilayon. Ang
ang file ng paglalarawan ay dapat maglaman ng sapat na impormasyon upang maunawaan ang sanhi ng
tunggalian. Kung saan ang kalabuan ang dahilan kung dapat ang default o tahasang mga panuntunan
sapat upang makabuo ng gumaganang parser.

Ang mga ipinahayag na mga nauuna at pagkakaugnay (tingnan Pahayag seksyon) ay sanay sa
lutasin ang mga salungatan sa pag-parse gaya ng sumusunod:

1. Ang isang precedence at associativity ay nauugnay sa bawat tuntunin ng grammar; ito ay ang
precedence at associativity ng huling token o literal sa katawan ng panuntunan. Kung
ang %prec ginagamit ang keyword, na-override nito ang default na ito. Maaaring hindi ang ilang tuntunin sa grammar
may parehong precedence at associativity.

2. Kung may pagbabago/bawasan ang salungatan, at pareho ang tuntunin sa gramatika at ang input na simbolo
magkaroon ng precedence at associativity na nauugnay sa kanila, pagkatapos ay nalutas ang salungatan
pabor sa aksyon (shift o reduce) na nauugnay sa mas mataas na precedence. Kung ang
ang mga nauuna ay pareho, pagkatapos ay ginagamit ang pagkakaugnay; ipinahihiwatig ng kaliwang associative
bawasan, ang tamang pag-uugnay ay nagpapahiwatig ng paglilipat, at ang hindi nag-uugnay ay nagpapahiwatig ng isang error sa
string na na-parse.

3. Kapag may shift/reduce conflict na hindi mareresolba ng rule 2, ang shift ay
tapos na. Ang mga salungatan na naresolba sa ganitong paraan ay binibilang sa diagnostic output na inilalarawan sa
pagkakamali Pag-asikaso.

4. Kapag may reduce/reduce conflict, ang reduction ay ginagawa ng grammar rule na
nangyayari nang mas maaga sa pagkakasunud-sunod ng pag-input. Ang mga salungatan na nalutas sa ganitong paraan ay binibilang sa
diagnostic output na inilarawan sa pagkakamali Pag-asikaso.

Ang mga salungatan na naresolba sa pamamagitan ng precedence o associativity ay hindi dapat ibilang sa shift/reduce
at bawasan/bawasan ang mga salungatan na iniulat ng yacc sa alinman sa karaniwang error o sa
file ng paglalarawan.

pagkakamali Pag-asikaso
Ang token mali ay dapat na nakalaan para sa paghawak ng error. Ang pangalan mali maaaring magamit sa
mga tuntunin sa gramatika. Ito ay nagpapahiwatig ng mga lugar kung saan ang parser ay makakabawi mula sa isang syntax error. Ang
default na halaga ng mali ay dapat 256. Maaaring baguhin ang halaga nito gamit ang a %token deklarasyon.
Hindi dapat ibalik ng lexical analyzer ang halaga ng mali.

Dapat makita ng parser ang isang error sa syntax kapag ito ay nasa isang estado kung saan nauugnay ang pagkilos
na may lookahead na simbolo ay mali. Ang isang semantic na aksyon ay maaaring maging sanhi ng pagsisimula ng parser
paghawak ng error sa pamamagitan ng pagsasagawa ng macro YYERROR. Kapag ang YYERROR ay naisakatuparan, ang semantic
ipinapasa ng aksyon ang kontrol pabalik sa parser. Ang YYERROR ay hindi maaaring gamitin sa labas ng semantic
aksyon.

Kapag nakita ng parser ang isang error sa syntax, karaniwan itong tumatawag yyerror() kasama ang karakter
pisi "syntax pagkakamali" bilang argumento nito. Ang tawag ay hindi dapat gawin kung ang parser ay pa rin
pagbawi mula sa isang nakaraang error kapag ang error ay nakita. Ang parser ay itinuturing na
ay bumabawi mula sa isang nakaraang error hanggang ang parser ay lumipat sa hindi bababa sa tatlo
normal na mga simbolo ng pag-input mula noong natukoy ang huling error o isang semantic na aksyon ang naisakatuparan
ang macro yyerrok. Ang parser ay hindi tatawag yyerror() kapag ang YYERROR ay naisakatuparan.

Ang macro function na YYRECOVERING ay magbabalik ng 1 kung may natukoy na syntax error at ang
Ang parser ay hindi pa ganap na nakakabawi mula dito. Kung hindi, ang zero ay ibabalik.

Kapag ang isang syntax error ay nakita ng parser, ang parser ay dapat suriin kung ang isang nakaraang syntax
may nakitang error. Kung may nakitang nakaraang error, at kung walang mga normal na simbolo ng pag-input
ay inilipat mula noong natukoy ang naunang error, sinusuri ng parser kung ang
Ang lookahead na simbolo ay isang endmarker (tingnan interface sa ang Leksikal Analyzer). Kung ito ay, ang
babalik ang parser na may hindi zero na halaga. Kung hindi, ang simbolo ng lookahead ay
itinapon at normal na pag-parse ay magpapatuloy.

Kapag ang YYERROR ay naisakatuparan o kapag ang parser ay nakakita ng isang syntax error at walang nakaraang error
ay nakita, o hindi bababa sa isang normal na simbolo ng pag-input ang inilipat mula noong nakaraan
may nakitang error, ang parser ay dapat mag-pop back ng isang estado sa isang pagkakataon hanggang sa ang parse stack ay
walang laman o ang kasalukuyang estado ay nagbibigay-daan sa paglipat mali. Kung walang laman ang parser sa parse
stack, babalik ito na may hindi zero na halaga. Kung hindi, ito ay lilipat mali at
pagkatapos ay ipagpatuloy ang normal na pag-parse. Kung nagbabasa ang parser ng isang lookahead na simbolo bago ang error
na-detect, ang simbolo na iyon ay magiging simbolo pa rin ng lookahead kapag ipinagpatuloy ang pag-parse.

Ang macro yyerrok sa isang semantikong aksyon ay dapat maging sanhi ng parser na kumilos na parang ganap na
nabawi mula sa anumang mga nakaraang error. Ang macro yclearin ay magiging dahilan upang itapon ang parser
ang kasalukuyang lookahead token. Kung hindi pa nababasa ang kasalukuyang lookahead token,
yclearin ay walang epekto.

Ang macro YYACCEPT ay magiging sanhi ng pagbabalik ng parser na may halagang zero. Ang macro YYABORT
dapat maging sanhi ng pagbabalik ng parser na may hindi zero na halaga.

interface sa ang Leksikal Analyzer
Ang yylex() function ay isang integer-valued function na nagbabalik ng a token numero
kumakatawan sa uri ng token na binasa. Kung may value na nauugnay sa token
ibinalik ni yylex() (tingnan ang talakayan ng mga tag sa itaas), ito ay itatalaga sa
panlabas na variable yylval.

Kung ang parser at yylex() hindi sumasang-ayon sa mga token number na ito, maaasahang komunikasyon
sa pagitan nila ay hindi maaaring mangyari. Para sa mga literal na (single-byte na character), ang token ay ang
numeric na halaga ng character sa kasalukuyang set ng character. Ang mga numero para sa iba pang mga token
maaaring piliin ng yacc, o pinili ng gumagamit. Sa alinmang kaso, ang # tukuyin tayuan
ng C ay ginagamit upang payagan yylex() upang ibalik ang mga numerong ito sa simbolikong paraan. Ang # tukuyin pahayag
ay inilalagay sa code file, at ang header file kung hihilingin ang file na iyon. Ang set ng
mga character na pinahihintulutan ng yacc sa isang identifier ay mas malaki kaysa sa pinahihintulutan ng C. Token
ang mga pangalan na natagpuang naglalaman ng mga naturang karakter ay hindi dapat isama sa # tukuyin mga deklarasyon.

Kung ang mga token number ay pinili ng yacc, ang mga token maliban sa mga literal ay itatalaga
mga numerong higit sa 256, bagama't walang pagkakasunod-sunod na ipinahiwatig. Ang isang token ay maaaring tahasang italaga
isang numero sa pamamagitan ng pagsunod sa unang paglitaw nito sa seksyon ng mga deklarasyon na may numero.
Ang mga pangalan at literal na hindi tinukoy sa ganitong paraan ay nagpapanatili ng kanilang default na kahulugan. Lahat ng token number
itinalaga ni yacc ay natatangi at naiiba sa mga token number na ginamit para sa mga literal at
mga token na itinalaga ng user. Kung ang mga duplicate na numero ng token ay nagdudulot ng mga salungatan sa pagbuo ng parser,
yacc dapat mag-ulat ng pagkakamali; kung hindi, hindi natukoy kung ang pagtatalaga ng token ay
tinanggap o may naiulat na error.

Ang dulo ng input ay minarkahan ng isang espesyal na token na tinatawag na endmarker, na may token
numero na zero o negatibo. (Ang mga halagang ito ay hindi wasto para sa anumang iba pang token.) Lahat
Ang mga lexical analyzer ay magbabalik ng zero o negatibo bilang isang token number sa pag-abot sa dulo ng
kanilang input. Kung ang mga token ay hanggang sa, ngunit hindi kasama, ang endmarker ay bumubuo ng isang istraktura na
tumutugma sa panimulang simbolo, tatanggapin ng parser ang input. Kung ang endmarker ay makikita sa
anumang iba pang konteksto, ito ay ituring na isang pagkakamali.

Pagkumpleto ang Programa
Bilang karagdagan sa yparse() at yylex(), ang mga function yyerror() at pangunahin() ay kinakailangan na
gumawa ng kumpletong programa. Ang application ay maaaring magbigay pangunahin() at yyerror(), o mga
ang mga gawain ay maaaring makuha mula sa yacc library.

Yacc Aklatan
Ang mga sumusunod na function ay lilitaw lamang sa yacc mapupuntahan ang aklatan sa pamamagitan ng −l y
operand sa c99; maaari silang muling tukuyin sa pamamagitan ng isang naaayon na aplikasyon:

int pangunahin(walang bisa)
Ang function na ito ay tatawag yparse() at lumabas na may hindi natukoy na halaga. Iba pang mga aksyon
sa loob ng function na ito ay hindi natukoy.

int yyerror(const tangke *s)
Dapat isulat ng function na ito ang NUL-terminated argument sa karaniwang error, na sinusundan ng
a .

Ang pagkakasunud-sunod ng −l y at −l l operand na ibinigay sa c99 ay makabuluhan; ang aplikasyon ay dapat
alinman magbigay ng sarili nitong pangunahin() gumana o tiyakin na −l y nauna −l l.

Pag-debug ang Parser
Ang parser na nabuo ni yacc ay dapat magkaroon ng mga diagnostic facility sa loob nito na maaaring opsyonal
pinagana sa oras ng pag-compile o sa runtime (kung pinagana sa oras ng pag-compile). Ang
Ang compilation ng runtime debugging code ay nasa ilalim ng kontrol ng YYDEBUG, isang preprocessor
simbolo. Kung ang YYDEBUG ay may hindi zero na halaga, ang debugging code ay dapat isama. Kung ito
ang halaga ay zero, ang code ay hindi dapat isama.

Sa mga parser kung saan isinama ang debugging code, ang external int yydebug ay maaaring maging
ginagamit upang i-on ang pag-debug (na may hindi zero na halaga) at patayin (zero na halaga) sa runtime. Ang
paunang halaga ng yydebug ay magiging zero.

Kailan −t ay tinukoy, ang code file ay bubuo nang ganoon, kung ang YYDEBUG ay wala pa
tinukoy sa oras ng compilation (gamit ang c99 −D YYDEBUG opsyon, halimbawa), YYDEBUG ay dapat
tahasang itakda sa 1. Kailan −t ay hindi tinukoy, ang code file ay dapat itayo nang sa gayon,
kung ang YYDEBUG ay hindi pa tinukoy, dapat itong tahasang itakda sa zero.

Ang format ng output ng pag-debug ay hindi tinukoy ngunit may kasamang hindi bababa sa sapat na impormasyon
upang matukoy ang paglilipat at bawasan ang mga aksyon, at ang mga simbolo ng input. Nagbibigay din ito
impormasyon tungkol sa pagbawi ng error.

Algorithm
Ang parser na binuo ni yacc nagpapatupad ng isang LALR(1) parsing algorithm gaya ng nakadokumento sa
ang panitikan. Ito ay hindi natukoy kung ang parser ay table-driven o direct-coded.

Isang parser na binuo ni yacc hindi kailanman hihiling ng input na simbolo mula sa yylex() habang nasa a
estado kung saan ang tanging mga aksyon maliban sa pagkilos ng error ay mga pagbawas ng isang panuntunan.

Ang panitikan ng parsing theory ay tumutukoy sa mga konseptong ito.

Mga Limitasyon
Ang yacc Ang utility ay maaaring may ilang mga panloob na talahanayan. Ang pinakamababang maximum para sa mga talahanayang ito
ay ipinapakita sa sumusunod na talahanayan. Ang eksaktong kahulugan ng mga halagang ito ay pagpapatupad-
tinukoy. Dapat tukuyin ng pagpapatupad ang kaugnayan sa pagitan ng mga halagang ito at sa pagitan
sila at anumang mga mensahe ng error na maaaring mabuo ng pagpapatupad sakaling maubusan ito
puwang para sa anumang panloob na istraktura. Maaaring pagsamahin ng isang pagpapatupad ang mga pangkat ng mga mapagkukunang ito
sa iisang pool hangga't ang kabuuang magagamit sa user ay hindi bababa sa kabuuan
ng mga sukat na tinukoy ng seksyong ito.

Talaan: Panloob Mga Limitasyon in yacc

┌───────────┬─────────┬─────────────────────────── ─────┐
│ │ Pinakamaliit │ │
│ Limitasyon │ Pinakamataas │ paglalarawan │
├───────────┼─────────┼─────────────────────────── ─────┤
│{NTERMS} │ 126 │ Bilang ng mga token. │
│{NONTERM} │ 200 │ Bilang ng mga hindi terminal. │
│{NPROD} │ 300 │ Bilang ng mga panuntunan. │
│{NSTATES} │ 600 │ Bilang ng mga estado. │
│{MEMSIZE} │ 5200 │ Haba ng mga panuntunan. Ang kabuuang │
│ │ │ haba, sa mga pangalan (mga token at │
│ │ │ hindi terminal), ng lahat ng │
│ │ │ tuntunin ng gramatika. Ang │
│ │ │ kaliwang bahagi ay binibilang para sa │
│ │ │ bawat tuntunin, kahit na hindi │
│ │ │ tahasang inulit, bilang │
│ │ │ tinukoy sa Gramatika Batas in │
│ │ │ yacc. │
│{ACTSIZE} │ 4000 │ Bilang ng mga aksyon. ``Mga Pagkilos'' │
│ │ │ dito (at sa paglalarawan │
│ │ │ file) sumangguni sa mga pagkilos ng parser │
│ │ │ (shift, bawasan, at iba pa) hindi │
│ │ │ sa mga semantikong aksyon na tinukoy sa │
│ │ │ Gramatika Batas in yacc. │
└───────────┴─────────┴─────────────────────────── ─────┘

EXIT STATUS

Ang mga sumusunod na exit value ay ibabalik:

0 Matagumpay na pagkumpleto.

>0 May naganap na error.

Mga kahihinatnan OF MGA KAMALI

Kung ang anumang mga error ay nakatagpo, ang pagtakbo ay aborted at yacc paglabas na may hindi zero na katayuan.
Maaaring gawin ang mga partial code file at header file. Ang buod ng impormasyon sa
ang file ng paglalarawan ay dapat palaging gawin kung ang −v naroroon ang bandila.

Ang sumusunod seksyon ay nagbibigay-kaalaman.

APLIKASYON PAGGAMIT

Ang mga makasaysayang pagpapatupad ay nakakaranas ng mga salungatan sa pangalan sa mga pangalan yacc.tmp, yacc.acts,
yacc.debug, y.tab.c, y.tab.h, at y.output kung higit sa isang kopya ng yacc ay tumatakbo sa a
iisang direktoryo sa isang pagkakataon. Ang −b ang opsyon ay idinagdag upang malampasan ang problemang ito. Ang
kaugnay na problema ng pagpayag ng maramihang yacc mga parser na ilalagay sa parehong file ay
tinutugunan sa pamamagitan ng pagdaragdag ng a −p opsyon na i-override ang dating hard-coded yy variable prefix.

Ang paglalarawan ng −p ang opsyon ay tumutukoy sa minimal na hanay ng function at variable na mga pangalan
na nagdudulot ng hindi pagkakasundo kapag maraming mga parser ang pinagsama-sama. Hindi kailangang maging YYSTYPE
nagbago. Sa halip, magagamit ng programmer −b upang ibigay ang mga file ng header para sa iba't ibang mga parser
iba't ibang pangalan, at pagkatapos ay ang file na may yylex() para sa isang ibinigay na parser ay maaaring isama ang
header para sa parser na iyon. Mga pangalan tulad ng yclearerr hindi kailangang baguhin dahil sila
ay ginagamit lamang sa mga aksyon; wala silang linkage. Posible na ang isang
Ang pagpapatupad ay may iba pang mga pangalan, alinman sa panloob para sa pagpapatupad ng mga bagay tulad ng
yclearerr, o pagbibigay ng hindi karaniwang mga feature na gusto nitong baguhin −p.

Ang mga unary operator na kapareho ng token bilang isang binary operator sa pangkalahatan ay nangangailangan ng kanilang
inayos ang precedence. Ito ay pinangangasiwaan ng %prec simbolo ng pagpapayo na nauugnay sa
partikular na tuntunin sa gramatika na tumutukoy sa unary operator. (Tingnan Gramatika Batas in yacc.)
Ang mga aplikasyon ay hindi kinakailangan na gamitin ang operator na ito para sa unary operator, ngunit ang mga grammar
na hindi nangangailangan nito ay bihira.

HALIMBAWA

Pag-access sa yacc ang library ay nakuha gamit ang library search operands sa c99. Upang magamit ang
yacc aklatan pangunahin():

c99 y.tab.c −l y

Ang parehong lex aklatan at ang yacc naglalaman ng aklatan pangunahin(). Upang ma-access ang yacc pangunahin():

c99 y.tab.c lex.yy.c −l y −l l

Tinitiyak nito na ang yacc Hinahanap muna ang library, upang ang pangunahin() Ginagamit.

Ang makasaysayan yacc Ang mga aklatan ay naglalaman ng dalawang simpleng function na karaniwang naka-code
ng application programmer. Ang mga function na ito ay katulad ng sumusunod na code:

# isama
int pangunahing(walang bisa)
{
panlabas int yyparse();

setlocale(LC_ALL, "");

/* Kung ang sumusunod na parser ay nilikha ng lex, ang
application ay dapat maging maingat upang matiyak na ang LC_CTYPE
at LC_COLLATE ay nakatakda sa POSIX locale. */
(walang bisa) yyparse();
bumalik (0);
}

# isama

int yyerror(const char *msg)
{
(walang bisa) fprintf(stderr, "%s\n", msg);
bumalik (0);
}

RATIONALE

Ang mga sanggunian sa Sumangguni Mga dokumento maaaring makatulong sa pagbuo ng parser
generator. Ang isinangguni na artikulong DeRemer at Pennello (kasama ang mga gawa nito
references) ay naglalarawan ng isang pamamaraan upang makabuo ng mga parser na umaayon sa dami na ito ng
POSIX.1–2008. Ang trabaho sa lugar na ito ay patuloy na ginagawa, kaya dapat kumunsulta ang mga tagapagpatupad
kasalukuyang panitikan bago gumawa ng anumang mga bagong pagpapatupad. Ang orihinal na artikulo ng Knuth ay ang
teoretikal na batayan para sa ganitong uri ng parser, ngunit ang mga talahanayan na nabuo nito ay hindi praktikal
malaki para sa makatwirang grammar at hindi dapat gamitin. Ang ``katumbas ng'' salita ay
sinadya upang tiyakin na ang pinakamahusay na mga talahanayan na LALR(1) maaaring mabuo.

Nagkaroon ng kalituhan sa pagitan ng klase ng mga grammar, ang mga algorithm na kailangan para makabuo
parser, at ang mga algorithm na kailangan para i-parse ang mga wika. Lahat sila ay makatwiran
orthogonal. Sa partikular, isang generator ng parser na tumatanggap ng buong hanay ng LR(1)
ang mga grammar ay hindi kailangang bumuo ng isang talahanayan na mas kumplikado kaysa sa isa na tumatanggap SLR(1) (a
medyo mahinang klase ng LR grammars) para sa isang grammar na nangyayari SLR(1). Ang nasabing isang
hindi kailangang kilalanin ng pagpapatupad ang kaso, alinman; table compression ay maaaring magbunga ng SLR(1)
talahanayan (o isa kahit na mas maliit kaysa doon) nang hindi kinikilala na ang grammar ay SLR(1). Ang
bilis ng isang LR(1) ang parser para sa anumang klase ay higit na nakadepende sa representasyon ng talahanayan at
compression (o ang pagbuo ng code kung ang isang direktang parser ay nabuo) kaysa sa klase
ng grammar na pinangangasiwaan ng table generator.

Ang bilis ng generator ng parser ay medyo nakadepende sa klase ng grammar nito
humahawak. Gayunpaman, ang orihinal na mga algorithm ng artikulo ng Knuth para sa pagbuo ng mga LR parser ay
hinuhusgahan ng may-akda nito na hindi praktikal na mabagal sa oras na iyon. Kahit full LR pa
kumplikado kaysa LALR(1), habang bumubuti ang mga bilis at algorithm ng computer, ang pagkakaiba (sa mga tuntunin
ng katanggap-tanggap na oras ng pagpapatupad ng wall-clock) ay nagiging hindi gaanong makabuluhan.

Ang mga potensyal na may-akda ay binabalaan na ang isinangguni na artikulong DeRemer at Pennello
ang naunang binanggit ay tumutukoy sa isang bug (isang sobrang pagpapasimple ng pagkalkula ng LALR(1)
lookahead set) sa ilan sa LALR(1) mga pahayag ng algorithm na nauna rito
publikasyon. Dapat silang maglaan ng oras upang hanapin ang papel na iyon, pati na rin ang kasalukuyang nauugnay
trabaho, lalo na kay Aho.

Ang −b ang opsyon ay idinagdag upang magbigay ng portable na paraan para sa pagpapahintulot yacc upang magtrabaho
maramihang hiwalay na mga parser sa parehong direktoryo. Kung ang isang direktoryo ay naglalaman ng higit sa isa
yacc grammar, at ang parehong grammar ay binuo sa parehong oras (sa pamamagitan ng, halimbawa, a
pagtularin gumawa programa), mga resulta ng salungatan. Bagama't ang solusyon ay hindi makasaysayang kasanayan,
itinutuwid nito ang isang kilalang kakulangan sa mga makasaysayang pagpapatupad. Ang mga kaukulang pagbabago ay
ginawa sa lahat ng mga seksyon na nag-refer sa mga filename y.tab.c (ngayon ``ang code file''),
y.tab.h (ngayon ``ang header file''), at y.output (ngayon ``ang file ng paglalarawan'').

Ang grammar para sa yacc Ang input ay batay sa dokumentasyon ng System V. Ang paglalarawan sa teksto
nagpapakita doon na ang ';' ay kinakailangan sa dulo ng panuntunan. Ang gramatika at ang
ang pagpapatupad ay hindi nangangailangan nito. (Ang gamit ng C_IDENTIFIER nagiging sanhi ng pagbabawas na mangyari sa
tamang lugar.)

Gayundin, sa pagpapatupad na iyon, ang mga konstruksyon tulad ng %token maaaring wakasan ng a
, ngunit hindi ito pinahihintulutan ng gramatika. Ang mga keyword tulad ng %token maaari
lumilitaw din sa malalaking titik, na muling hindi tinalakay. Sa karamihan ng mga lugar kung saan '%' Ginagamit,
maaaring palitan, at may mga kahaliling spelling para sa ilan sa mga simbolo
(Halimbawa, %LEFT ay maaaring maging "%<" o kahit na "\<").

Sa kasaysayan,mga tag> maaaring maglaman ng anumang mga character maliban '>', kabilang ang puting espasyo, sa
pagpapatupad. Gayunpaman, dahil ang mga tag dapat sumangguni sa isang ISO C standard na miyembro ng unyon, sa
Ang mga pagpapatupad ng pagsasanay sa pagsunod ay kailangang suportahan lamang ang hanay ng mga character para sa ISO C
mga karaniwang identifier sa kontekstong ito.

Ang ilang makasaysayang pagpapatupad ay kilala na tumatanggap ng mga aksyon na winakasan ng a
panahon. Ang mga makasaysayang pagpapatupad ay madalas na pinapayagan '$' sa mga pangalan. Isang naaayon na pagpapatupad
ay hindi kailangang suportahan ang alinman sa mga pag-uugaling ito.

Pagpapasya kung kailan gagamitin %prec inilalarawan ang kahirapan sa pagtukoy ng pag-uugali ng yacc.
Maaaring may mga sitwasyon kung saan ang gramatika ay hindi, mahigpit na pagsasalita, sa pagkakamali, at gayon pa man
yacc hindi maaaring bigyang-kahulugan ito nang malinaw. Ang paglutas ng mga kalabuan sa gramatika ay maaaring
sa maraming pagkakataon ay malulutas sa pamamagitan ng pagbibigay ng karagdagang impormasyon, tulad ng paggamit %type or
%unyon mga deklarasyon. Ito ay kadalasang mas madali at kadalasan ay nagbubunga ito ng mas maliit na parser na kukunin
ang alternatibong ito kapag ito ay angkop.

Ang laki at oras ng pagpapatupad ng isang program na ginawa nang walang runtime debugging code ay
karaniwang mas maliit at bahagyang mas mabilis sa mga makasaysayang pagpapatupad.

Kasama sa mga mensahe ng istatistika mula sa ilang makasaysayang pagpapatupad ang mga sumusunod na uri ng
impormasyon:

n/512 na mga terminal, n/300 na hindi terminal
n/600 tuntunin sa gramatika, n/1500 estado
n shift/bawas, n bawasan/bawasan ang mga salungatan na iniulat
n/350 working sets ang ginamit
Memorya: estado, atbp. n/15000, parser n/ 15000
n/600 natatanging hanay ng lookahead
n dagdag na pagsasara
n shift entry, n pagbubukod
n goto entries
n na-save ang mga entry sa pamamagitan ng goto default
Optimizer space na ginamit: input n/15000, output n/ 15000
n mga entry sa talahanayan, n wala
Pinakamataas na pagkalat: n, Pinakamataas na offset: n

Ang ulat ng mga panloob na talahanayan sa file ng paglalarawan ay naiwan na tinukoy sa pagpapatupad
dahil ang lahat ng aspeto ng mga limitasyong ito ay tinukoy din sa pagpapatupad. Ilang mga pagpapatupad
maaaring gumamit ng mga dynamic na diskarte sa paglalaan at walang tiyak na mga halaga ng limitasyon na iuulat.

Ang pormat ng y.output file ay hindi ibinigay dahil ang detalye ng format ay hindi
nakikita upang mapahusay ang portability ng mga application. Ang listahan ay pangunahing inilaan upang tulungan ang tao
naiintindihan at na-debug ng mga user ang parser; paggamit ng y.output sa pamamagitan ng isang naaayon na script ng aplikasyon
ay hindi karaniwan. Higit pa rito, ang mga pagpapatupad ay hindi nakagawa ng pare-parehong output at hindi
sikat na format ay maliwanag. Ang format na pinili ng pagpapatupad ay dapat na human-
nababasa, bilang karagdagan sa kinakailangan na ito ay isang text file.

Ang mga karaniwang ulat ng error ay hindi partikular na inilarawan dahil bihira itong gamitin
umaayon sa mga aplikasyon at walang dahilan upang paghigpitan ang mga pagpapatupad.

Kinikilala ng ilang mga pagpapatupad "="{" bilang katumbas ng '{' dahil lumalabas ito sa historical
dokumentasyon. Ang konstruksiyon na ito ay kinilala at naidokumento bilang lipas na noong unang panahon
1978, sa binanggit Yacc: Pa Isa pa Compiler-Compiler. Ang volume na ito ng POSIX.1–2008
piniling iwan ito bilang lipas na at alisin ito.

Ang mga multi-byte na character ay dapat kilalanin ng lexical analyzer at ibalik bilang mga token.
Hindi dapat ibalik ang mga ito bilang mga literal na multi-byte na character. Ang token mali na ginagamit
para sa pagbawi ng error ay karaniwang itinalaga ang halaga 256 sa makasaysayang pagpapatupad.
Kaya, ang token value na 256, na ginagamit sa maraming multi-byte character set, ay hindi
magagamit para gamitin bilang halaga ng token na tinukoy ng user.

PAGTATAYA DIREKSYON

Wala.

Gamitin ang yaccposix online gamit ang mga serbisyo ng onworks.net