gpp - Online sa Cloud

PROGRAMA:

NAME

GPP - Generic na Preprocessor

SINOPSIS

gpp [-{o|O} outfile] [-Ako/include/path] [-Dpangalan=val ...]
[-z|+z] [-x] [-m] [-C|-T|-H|-X|-P|-U ... [-M ...]]
[-n|+n] [+c str1 str2] [+s str1 str2 c]
[-c str1] [--nostdinc] [--nocurinc]
[--curdirinclast] [--warninglevel n]
[--includemarker STR] [--isama file]
[infile]

gpp --tulong

gpp --bersyon

DESCRIPTION

Ang GPP ay isang pangkalahatang layunin na preprocessor na may napapasadyang syntax, na angkop para sa isang malawak na hanay
ng mga gawaing preprocessing. Ang pagsasarili nito mula sa anumang programming language ay ginagawang higit pa
versatile kaysa sa cpp, habang ang syntax nito ay mas magaan at mas flexible kaysa sa m4.

Naka-target ang GPP sa lahat ng karaniwang gawain sa preprocessing kung saan hindi angkop ang cpp at kung saan hindi
kailangan ang napaka sopistikadong mga tampok. Upang makapagproseso ng pantay na mahusay
mga text file o source code sa iba't ibang wika, ang syntax na ginagamit ng GPP ay ganap
napapasadya. Ang paghawak ng mga komento at mga string ay lalo na advanced.

Sa una, naiintindihan lang ng GPP ang isang kaunting hanay ng mga built-in na macro, na tinatawag meta-macros.
Ang mga meta-macros na ito ay nagpapahintulot sa kahulugan ng gumagamit macros pati na rin ang ilang mga pangunahing operasyon
bumubuo ng core ng preprocessing system, kabilang ang mga conditional test, aritmetika
pagsusuri, pagtutugma ng wildcard (globbing), at detalye ng syntax. Lahat ng user macro
ang mga kahulugan ay pandaigdigan -- ibig sabihin, nananatili silang wasto hanggang sa tahasang maalis; meta-macros
hindi maaaring muling tukuyin. Sa bawat user macro definition sinusubaybayan ng GPP ang katumbas
pagtutukoy ng syntax upang ang isang macro ay ligtas na ma-invoke anuman ang anumang kasunod nito
pagbabago sa operating mode.

Bilang karagdagan sa mga macro, naiintindihan ng GPP ang mga komento at string, kung saan ang syntax at pag-uugali ay maaaring
malawak na ipasadya upang magkasya sa anumang partikular na layunin. Ang mga panloob na komento at mga string ay
ang parehong konstruksiyon, kaya lahat ng naaangkop sa mga komento ay nalalapat din sa mga string.

Opsyon

Kinikilala ng GPP ang mga sumusunod na command-line switch at mga opsyon. Tandaan na ang -nostdinc,
-nocurinc, -curdirinclast, -warninglevel, at -includemarker na mga opsyon mula sa bersyon 2.1 at
mas maaga ay hindi na ginagamit at hindi dapat gamitin. Gamitin na lang ang mga variant na "mahabang opsyon."
(--nostdinc, at iba pa).

-h - Tumulong
Mag-print ng maikling mensahe ng tulong.

--bersyon
Impormasyon sa bersyon ng pag-print.

-o outfile
Tukuyin ang isang file kung saan dapat ipadala ang lahat ng output (bilang default, lahat ay ipinadala
sa karaniwang output).

-O outfile
Tukuyin ang isang file kung saan dapat ipadala ang lahat ng output; output ay sabay-sabay na ipinadala sa
stdout.

-I/include/path
Tukuyin ang isang landas kung saan ang # isama Ang meta-macro ay maghahanap ng mga kasamang file kung sila
ay wala sa kasalukuyang direktoryo. Ang default ay / usr / isama kung hindi -ako
ang pagpipilian ay tinukoy. Maaaring tukuyin ang maramihang -I na mga opsyon upang tingnan ang ilan
mga direktoryo.

-Dpangalan=val
Tukuyin ang macro ng gumagamit pangalan bilang katumbas ng Val. Ito ay mahigpit na katumbas ng paggamit
ang # tukuyin meta-macro, ngunit ginagawang posible na tukuyin ang mga macro mula sa command-
linya Kung Val gumagawa ng mga sanggunian sa mga argumento o iba pang mga macro, dapat itong sumunod sa
ang syntax ng mode na tinukoy sa command-line. Simula sa bersyon 2.1,
Ang pagpapangalan ng macro argument ay pinapayagan sa command-line. Ang syntax ay ang mga sumusunod:
-Dmacro(arg1,...)=depinisyon. Ang mga argumento ay tinukoy sa C-style syntax,
nang walang anumang whitespace, ngunit ang kahulugan ay dapat pa ring sumunod sa syntax ng
ang mode na tinukoy sa command-line.

+z Itakda ang text mode sa Unix mode (LF terminator). Anumang CR character sa input ay
sistematikong itinatapon. Ito ang default sa ilalim ng mga Unix system.

-z Itakda ang text mode sa DOS mode (CR-LF terminator). Sa mode na ito lahat ng CR character ay
inalis mula sa input, at lahat ng output LF character ay na-convert sa CR-LF. Ito
ay ang default kung ang GPP ay pinagsama-sama sa opsyong WIN_NT.

-x Paganahin ang paggamit ng #exec meta-macro. Since #exec kasama ang output ng isang
arbitrary shell command line, maaari itong magdulot ng potensyal na banta sa seguridad, at sa gayon
hindi pinagana maliban kung ang pagpipiliang ito ay tinukoy.

-m Paganahin ang awtomatikong mode na lumipat sa cpp compatibility mode kung ang pangalan ng isang
nagtatapos sa `.h' o `.c' ang kasamang file. Ginagawa nitong posible na isama ang C header
mga file na may kaunting pagbabago lamang.

-n Pigilan ang mga newline o whitespace na character na maalis mula sa input kapag
nagaganap ang mga ito bilang pagtatapos ng isang macro call o ng isang komento. Bilang default, kapag ang isang bagong linya
o whitespace na character ang bumubuo sa dulo ng isang macro o isang komento na ito ay na-parse bilang bahagi
ng macro call o komento at samakatuwid ay inalis sa output. Gamitin ang -n na opsyon
upang panatilihin ang huling character sa input stream kung ito ay whitespace o isang bagong linya.
Ito ay isinaaktibo sa cpp at Prolog mode.

+n Ang kabaligtaran ng -n. Ito ang default sa lahat ng mga mode maliban sa cpp at Prolog. Tandaan
dapat ilagay ang +n na iyon pagkatapos -C o -P upang magkaroon ng anumang epekto.

-U arg1 ... arg9
Mode na tinukoy ng gumagamit. Ang siyam na sumusunod na argumento sa command-line ay itinuturing na
ayon sa pagkakabanggit ang macro start sequence, ang macro end sequence para sa isang tawag na wala
argumento, ang pagkakasunod-sunod ng pagsisimula ng argumento, ang separator ng argumento, ang pagtatapos ng argumento
sequence, ang listahan ng mga character na isalansan para sa pagbabalanse ng argumento, ang listahan ng
mga character na i-unstack, ang string na gagamitin para sa pagtukoy sa isang argumento ni
numero, at sa wakas ay ang quote character (kung walang isang walang laman na string ay dapat na
ibinigay). Nalalapat ang mga setting na ito sa mga macro ng user at sa mga meta-macros, maliban kung ang
-M na opsyon ay ginagamit upang tukuyin ang iba pang mga setting para sa meta-macros. Tingnan ang seksyon sa
pagtutukoy ng syntax para sa higit pang mga detalye.

-M arg1 ... arg7
Mga detalye ng mode na tinukoy ng gumagamit para sa meta-macros. Magagamit lamang ang opsyong ito
kasama si -M. Ang pitong sumusunod na argumento sa command-line ay itinuturing na
ayon sa pagkakabanggit ang macro start sequence, ang macro end sequence para sa isang tawag na wala
argumento, ang pagkakasunod-sunod ng pagsisimula ng argumento, ang separator ng argumento, ang pagtatapos ng argumento
pagkakasunud-sunod, ang listahan ng mga character na isasalansan para sa pagbabalanse ng argumento, at ang listahan ng
mga character na i-unstack. Tingnan sa ibaba para sa higit pang mga detalye.

(default fashion)
Ang default na mode ay isang malabong cpp-like mode, ngunit hindi nito pinangangasiwaan ang mga komento, at
nagpapakita ng iba't ibang hindi pagkakatugma sa cpp. Karaniwang meta-macros at user macro
kamukha nito:

#define xy
macro(arg,...)

Ang mode na ito ay katumbas ng

-U "" "" "(" "," ")" "(" ")" "#" "\\"
-M "#" "\n" " " " " "\n" "(" ")"

-C mode ng compatibility ng cpp. Ito ang mode kung saan pinakamalapit ang gawi ng GPP
yung sa cpp. Hindi tulad sa default na mode, ang meta-macro expansion ay nangyayari lamang sa
simula ng mga linya, at ang mga komento at mga string ng C ay nauunawaan. Ang mode na ito ay
katumbas ng

-n -U "" "" "(" "," ")" "(" ")" "#" ""
-M "\n#\w" "\n" " " " " "\n" "" ""
+c "/*" "*/" +c "//" "\n" +c "\\\n" ""
+s "\"" "\"" "\\" +s "'" "'" "\\"

-T TeX-like mode. Sa mode na ito, ang karaniwang meta-macros at user macro ay ganito ang hitsura:

\define{x}{y}
\macro{arg}{...}

Walang mga komento ang naiintindihan. Ang mode na ito ay katumbas ng

-U "\\" "" "{" "}{" "}" "{" "}" "#" "@"

-H HTML-like mode. Sa mode na ito, ang karaniwang meta-macros at user macro ay ganito ang hitsura:

<#define x|y>
<#macro arg|...>

Walang mga komento ang naiintindihan. Ang mode na ito ay katumbas ng

-U "<#" ">" "\B" "|" ">" "<" ">" "#" "\\"

-X XHTML-like mode. Sa mode na ito, ang karaniwang meta-macros at user macro ay ganito ang hitsura:

<#define x|y/>
<#macro arg|.../>

Walang mga komento ang naiintindihan. Ang mode na ito ay katumbas ng

-U "<#" "/>" "\B" "|" "/>" "<" ">" "#" "\\"

-P Prolog-compatible cpp-like mode. Ang mode na ito ay naiiba sa cpp compatibility mode
sa pamamagitan ng paghawak nito ng mga komento, at katumbas ng

-n -U "" "" "(" "," ")" "(" ")" "#" ""
-M "\n#\w" "\n" " " " " "\n" "" ""
+ccss "\!o/*" "*/" +ccss "%" "\n" +ccii "\\\n" ""
+s "\"" "\"" "" +s "\!#'" "'" ""

+c str1 str2
Tukuyin ang mga komento. Anumang hindi nabanggit na pangyayari ng str1 ay bibigyang-kahulugan bilang ang
simula ng komento. Lahat ng input hanggang sa unang kasunod na paglitaw ng str2 habilin
itatapon. Maaaring gamitin ang opsyong ito nang maraming beses upang tukuyin ang iba't ibang uri ng
mga delimiter ng komento. Ang opsyonal na parameter maaaring tukuyin upang baguhin ang
pag-uugali ng komento at, hal, gawing string o huwag pansinin sa ilalim
ilang mga pangyayari, tingnan sa ibaba.

-c str1
I-unspecify ang mga komento o string. Ang detalye ng komento/string na ang simula
pagkakasunud-sunod ay str1 ay tinanggal. Ito ay kapaki-pakinabang upang baguhin ang built-in na komento
mga pagtutukoy ng isang karaniwang mode -- hal, ang cpp compatibility mode.

+s str1 str2 c
Tukuyin ang mga string. Anumang hindi nabanggit na pangyayari ng str1 ay bibigyang-kahulugan bilang ang
simula ng isang string. Lahat ng input hanggang sa unang kasunod na paglitaw ng str2 habilin
maging output nang walang anumang pagsusuri. Ang mga delimiter mismo ay output. Kung c
ay walang laman, ang unang karakter nito ay ginagamit bilang a string-quote katangian -- ibig sabihinSa
karakter na ang presensya kaagad bago ang isang pangyayari ng str2 pinipigilan ito mula sa
pagwawakas ng string. Ang opsyonal na parameter maaaring tukuyin upang baguhin ang
pag-uugali ng string at, hal, gawin itong komento, paganahin ang macro evaluation
sa loob ng string, o huwag pansinin ang detalye ng string sa ilalim ng tiyak
mga pangyayari. Tingnan sa ibaba.

-s str1
I-unspecify ang mga komento o string. Kapareho ng -c.

--isama file
paraan file bago infile

--nostdinc
Huwag maghanap ng mga file na kasama sa karaniwang direktoryo /usr/include.

--nocurinc
Huwag maghanap ng mga file na kasama sa kasalukuyang direktoryo.

--curdirinclast
Maghanap ng mga kasamang file sa kasalukuyang direktoryo pagkatapos ang mga direktoryo na tinukoy ni
-I kaysa bago sila.

--babala antas n
Itakda ang antas ng babala sa n (0, 1 o 2). Default ay 2 (pinaka-verbose).

--includemarker STR
subaybayan # isama mga direktiba sa pamamagitan ng paglalagay ng marker sa output stream. Ang
ang format ng marker ay tinutukoy ng STR, na dapat maglaman ng tatlong paglitaw ng
ang tauhan % (o katumbas nito ?). Ang unang pangyayari ay pinalitan ng linya
numero, ang pangalawa ay may pangalan ng file, at ang pangatlo ay may 1, 2 o blangko. Kapag ganito
ang opsyon ay tinukoy sa default, cpp o Prolog mode, ginagawa ng GPP ang lahat upang matiyak
na ang mga numero ng linya ay pareho sa output tulad ng sa input sa pamamagitan ng pagpasok ng blangko
mga linya sa lugar ng mga kahulugan o komento.

infile Tumukoy ng input file kung saan binabasa ng GPP ang input nito. Kung walang input file ay
tinukoy, ang input ay binabasa mula sa karaniwang input.

SINTAX Detalye

Ang syntax ng isang macro call ay ang mga sumusunod: dapat itong magsimula sa isang sequence ng mga character
tumutugma sa macro simula pagkakasunud-sunod tulad ng tinukoy sa kasalukuyang mode, sinundan kaagad
sa pangalan ng macro, na dapat ay wasto pantukoy -- ibig sabihin, isang pagkakasunod-sunod ng mga titik,
digit, o underscore ("_"). Ang macro name ay dapat na sinundan ng a maikli macro dulo
pagkakasunud-sunod kung ang macro ay walang mga argumento, o sa pamamagitan ng isang sequence ng mga argumento na pinasimulan ng isang
argumento simula pagkakasunud-sunod. Ang iba't ibang mga argumento ay pinaghihiwalay ng isang argumento
panghiwalay, at ang macro ay nagtatapos sa a mahaba macro dulo pagkakasunud-sunod.

Sa lahat ng kaso, ang mga parameter ng kasalukuyang konteksto -- ibig sabihin, ang mga argumento ay ipinasa sa
katawan na sinusuri -- maaaring tukuyin sa pamamagitan ng paggamit ng isang argumento sanggunian pagkakasunud-sunod
na sinusundan ng isang digit sa pagitan ng 1 at 9. Bilang kahalili, maaaring pangalanan ang mga macro parameter (tingnan
sa ibaba). Higit pa rito, upang maiwasan ang interference sa pagitan ng GPP syntax at ng mga nilalaman ng
input file, a sipi katangian ay ibinigay. Maaaring gamitin ang quote character upang maiwasan ang
interpretasyon ng isang macro na tawag, komento, o string bilang anumang bagay maliban sa plain text. Ang quote
"pinoprotektahan" ng karakter ang sumusunod na karakter, at palaging inaalis sa panahon ng pagsusuri.
Dalawang magkasunod na quote character ang sinusuri bilang isang solong quote character.

Panghuli, upang mapadali ang wastong pagtatanggal ng argumento, ang ilang mga character ay maaaring "sinalansan"
kapag nangyari ang mga ito sa isang macro argument, upang ang argument separator o macro end sequence
ay hindi na-parse kung ang katawan ng argumento ay hindi balanse. Nagbibigay-daan ito sa mga nesting macro call
nang hindi gumagamit ng mga panipi. Kung kinakailangan ang isang hindi wastong balanseng argumento, mag-quote ng mga character
dapat idagdag sa harap ng ilang nakasalansan na character para maging balanse ito.

Ang mga macro construction sequence na inilarawan sa itaas ay maaaring iba para sa meta-macros at para sa
user macros: ito ang kaso sa cpp mode, halimbawa. Tandaan na, dahil maaari ang meta-macros
mayroon lamang hanggang dalawang argumento, ang mga panuntunan sa delimitation para sa pangalawang argumento ay medyo
sloppier, at unquoted argument separator sequence ay pinapayagan sa ikalawang argument ng
isang meta-macro.

Maliban kung ang isa sa mga karaniwang operating mode ay pinili, ang mga sequence ng syntax sa itaas ay maaaring
tinukoy alinman sa command-line, gamit ang -M at -U na mga opsyon ayon sa pagkakabanggit para sa meta-
macros at user macros, o sa loob ng isang input file sa pamamagitan ng #fashion meta at #fashion gumagamit meta-
mga macro na tawag. Sa parehong mga kaso ang paglalarawan ng mode ay binubuo ng siyam na mga parameter para sa user
mga pagtutukoy ng macro, katulad ng macro start sequence, ang maikling macro end sequence, ang
argument start sequence, ang argument separator, ang mahabang macro end sequence, ang string
naglilista ng mga character na sasalansan, ang string na naglilista ng mga character na aalisin, ang argumento
reference sequence, at panghuli ang quote character. Tulad ng ipinaliwanag sa ibaba, ang mga pagkakasunud-sunod na ito
dapat ibigay gamit ang syntax ng mga C string; dapat silang magsimula sa isang hindi alphanumeric
character, at sa unang limang mga string ay maaaring gamitin ang mga espesyal na pagtutugma ng pagkakasunud-sunod (tingnan
sa ibaba). Kung ang argumentong naaayon sa quote character ay ang walang laman na string, iyon
naka-disable ang functionality ng argument. Para sa mga pagtutukoy ng meta-macro mayroon lamang pito
mga parameter, dahil ang pagkakasunud-sunod ng sanggunian ng argumento at karakter ng quote ay ibinabahagi sa
macro syntax ng gumagamit.

Ang istraktura ng isang komento/string ay ang mga sumusunod: dapat itong magsimula sa isang sequence ng
mga character na tumutugma sa ibinigay komento/string simula pagkakasunud-sunod, at palaging nagtatapos sa una
paglitaw ng mga komento/string dulo pagkakasunud-sunod, maliban kung ito ay nauunahan ng isang kakaibang bilang ng
mga pangyayari ng string-quote katangian (kung ang naturang karakter ay tinukoy). Sa
ilang mga kaso ang komento/mga string ay maaaring tukuyin upang paganahin ang macro evaluation sa loob ng
komento/string; sa kasong iyon, kung ang isang quote na character ay tinukoy para sa mga macro, maaari itong maging
ginamit din upang maiwasan ang komento/string mula sa pagtatapos, na may pagkakaiba na ang macro
quote character ay palaging inalis mula sa output samantalang ang string-quote character ay palaging
output. Tandaan din na sa ilalim ng ilang partikular na pangyayari ay maaaring magkaroon ng komento/string detalye
hindi pinagana, kung saan ang sequence ng pagsisimula ng komento/string ay binabalewala lang. Sa wakas, ito
ay posibleng tukuyin ang a pisi babala katangian na ang presensya sa loob ng isang komento/string
ay magiging sanhi ng GPP na maglabas ng babala (ito ay kapaki-pakinabang upang mahanap ang mga hindi natapos na string sa cpp
mode). Tandaan na ang mga input file ay hindi pinapayagang maglaman ng mga hindi natatapos na komento/mga string.

Maaaring ideklara ang isang komento/string na detalye mula sa loob ng input file gamit ang #fashion
puna meta-macro na tawag (o katumbas nito #fashion pisi), kung saan ang bilang ng C
mga string na ibibigay bilang mga argumento upang ilarawan ang komento/string ay maaaring nasaanman sa pagitan
dalawa at apat: ang unang dalawang argumento (mandatory) ay ang pagkakasunod-sunod ng simula at ang wakas
pagkakasunud-sunod, at maaaring gamitin ang mga espesyal na pagtutugma ng mga pagkakasunud-sunod (tingnan sa ibaba). Maaaring hindi sila
magsimula sa mga alphanumeric na character. Ang unang karakter ng ikatlong argumento, kung mayroon
isa, ay ginagamit bilang string-quote na character (gumamit ng walang laman na string upang huwag paganahin ang
functionality), at ang unang karakter ng ikaapat na argumento, kung mayroon man, ay ginagamit
bilang string-warning character. Ang isang detalye ay maaari ding ibigay mula sa command-line,
kung saan dapat mayroong dalawang argumento kung gumagamit ng +c na opsyon at tatlo kung gumagamit ng +s
pagpipilian.

Ang pag-uugali ng isang komento/string ay tinukoy ng isang tatlong-character na string ng modifier, na
maaaring ipasa bilang isang opsyonal na argumento sa +c/+s command-line na mga opsyon o sa
#fashion puna/#fashion pisi meta-macros. Kung walang tinukoy na string ng modifier, ang default
ang value ay "ccc" para sa mga komento at "sss" para sa mga string. Ang unang karakter ay tumutugma sa
pag-uugali sa loob ng mga meta-macro na tawag (kabilang ang mga kahulugan ng user-macro dahil ang mga ito ay pumasok sa loob
a # tukuyin meta-macro call), ang pangalawang karakter ay tumutugma sa pag-uugali sa loob ng user-
macro parameter, at ang pangatlong character ay tumutugma sa pag-uugali sa labas ng anumang macro
tawag. Ang bawat isa sa mga character na ito ay maaaring kumuha ng mga sumusunod na halaga:

i huwag paganahin ang detalye ng komento/string.

c komento (hindi nasuri o output).

s string (ang string at ang delimiter sequence nito ay output as-is).

q quoted string (ang string ay output as-is, nang walang delimiter sequence).

C nasuri na komento (nasusuri ang mga macro, ngunit itinatapon ang output).

S nasuri na string (nasusuri ang mga macro, ang mga delimiter ay output).

Q sinusuri ang naka-quote na string (nasusuri ang mga macro, hindi output ang mga delimiter).

Mahalagang tala: anumang paglitaw ng isang komento/string na pagkakasunud-sunod ng pagsisimula sa loob ng isa pa
Ang komento/string ay palaging binabalewala, kahit na naka-enable ang macro evaluation. Sa ibang salita,
ang mga komento/mga string ay hindi maaaring ma-nest. Sa partikular, ang modifier ng `Q' ay maaaring maging isang maginhawang paraan
ng pagtukoy ng syntax para sa pansamantalang hindi pagpapagana ng lahat ng komento at pagtutukoy ng string.

Ang mga string ng detalye ng syntax ay dapat palaging ibigay bilang mga C string, maging sila man
ibinigay bilang mga argumento sa a #fashion meta-macro na tawag o sa command-line ng isang Unix shell. Kung
Ang mga argumento ng command-line ay ibinibigay sa pamamagitan ng isa pang pamamaraan kaysa sa isang karaniwang shell ng Unix, pagkatapos ay ang
dapat tularan ang pag-uugali ng shell -- ibig sabihin, ang nakapaligid na "" quotes ay dapat alisin, lahat
ang mga paglitaw ng `\\' ay dapat mapalitan ng isang solong backslash, at sa katulad na paraan, ang `\"' ay dapat
pinalitan ng `"'. Ang mga pagkakasunud-sunod tulad ng `\n' ay kinikilala ng GPP at dapat na iwanang ganoon.

Maaaring gumamit ng mga espesyal na sequence na tumutugma sa ilang subset ng character set. Sila ay ng
ang form `\x', saan x ay isa sa:

b tumutugma sa anumang pagkakasunud-sunod ng isa o higit pang mga puwang o mga character ng tab (`\b' ay kapareho ng
` ').

w tumutugma sa anumang pagkakasunud-sunod ng zero o higit pang mga puwang o mga character ng tab.

B tumutugma sa anumang pagkakasunud-sunod ng isa o higit pang mga puwang, tab o bagong linya na mga character.

W tumutugma sa anumang pagkakasunud-sunod ng zero o higit pang mga puwang, mga tab o mga bagong linya na character.

a isang alpabetikong karakter (`a' hanggang `z' at `A' hanggang `Z').

A isang alpabetikong karakter, o isang puwang, tab o bagong linya.

# isang digit (`0' hanggang `9').

i isang identifier character. Ang hanay ng mga katugmang character ay nako-customize gamit ang
#fashion charset id utos. Ang default na setting ay tumutugma sa mga alphanumeric na character at
underscore (`a' hanggang `z', `A' hanggang `Z', `0' hanggang `9' at `_').

t isang tab na character.

n isang bagong linyang karakter.

o isang karakter ng operator. Ang hanay ng mga katugmang character ay nako-customize gamit ang
#fashion charset op utos. Ang default na setting ay tumutugma sa lahat ng mga character sa
"+-*/\^<>=`~:.?@#&!%|", maliban sa Prolog mode kung saan ang `!', `%' at `|' hindi
naitugma.

O isang karakter ng operator o isang character na panaklong. Ang set ng karagdagang tugma
ang mga character kumpara sa `\o' ay nako-customize gamit ang #fashion charset pagkakapantay
utos. Ang default na setting ay ang pagkakaroon ng mga character sa "()[]{}" bilang mga panaklong.

Bukod dito, ang lahat ng tumutugmang subset na ito maliban sa `\w' at `\W' ay maaaring balewalain sa pamamagitan ng paglalagay ng
`!' -- ibig sabihin, sa pamamagitan ng pagsulat ng `\!x' sa halip na `\x'.

Pansinin ang isang mahalagang natatanging katangian ng simula pagkakasunud-sunod: kapag ang unang karakter ng a
macro o comment/string start sequence ay ' ' o isa sa mga espesyal na sequence sa itaas, ito ay
hindi kinuha na bahagi ng mismong sequence ngunit ginagamit sa halip bilang isang context check: para sa
halimbawa ang isang start sequence na nagsisimula sa '\n' ay tumutugma lamang sa simula ng isang linya, ngunit
ang katugmang karakter ng bagong linya ay hindi kinuha bilang bahagi ng pagkakasunud-sunod. Katulad ng simula
ang sequence na nagsisimula sa ' ' ay tumutugma lamang kung may ilang whitespace, ngunit ang pagtutugma
Ang whitespace ay hindi itinuturing na bahagi ng sequence ng pagsisimula at samakatuwid ay ipinadala sa
output. Kung ang isang context check ay isinasagawa sa pinakadulo simula ng isang file (o mas pangkalahatan
ng anumang katawan na susuriin), ang resulta ay kapareho ng pagtutugma sa isang character na bagong linya
(ginagawa nitong posible para sa isang cpp-mode na file na magsimula sa isang meta-macro na tawag).

Dalawang espesyal na panuntunan ng syntax ang idinagdag sa bersyon 2.1. Una, mga sangguniang argumento (#n) ay hindi
mas matagal na sinusuri kapag wala sila sa mga macro na tawag at kahulugan. Gayunpaman, sila ay
hindi na pinapayagang lumitaw (maliban kung protektado ng mga quote character) sa loob ng isang tawag sa a
tinukoy na macro ng gumagamit; ang kasalukuyang gawi (paatras na katugma) ay alisin ang mga ito nang tahimik
mula sa input kung nangyari iyon.

Pangalawa, kung ang pagkakasunud-sunod ng pagtatapos (para sa mga macro o komento) ay binubuo ng isang bagong linya
karakter, at kung ang mga panuntunan sa delimitasyon ay humahantong sa pagsusuri sa isang konteksto kung saan ang pangwakas
wala ang newline na character, tahimik na binabalewala ng GPP ang nawawalang newline sa halip na gumawa
isang error. Ang pangunahing kahihinatnan ay ang mga meta-macro na tawag ay maaari na ngayong ma-nest sa isang simpleng paraan
sa standard, cpp at Prolog mode.

Paghusga MGA ALITUNTUNIN

Ang input ay binabasa nang sunud-sunod at binibigyang-kahulugan ayon sa mga patakaran ng kasalukuyang mode. Lahat
Ang input text ay unang itinugma laban sa tinukoy na mga sequence ng pagsisimula ng komento/string ng
kasalukuyang mode (maliban sa mga hindi pinagana ng 'i' modifier), maliban kung ang katawan
ang nasuri ay ang mga nilalaman ng isang komento/string na ang modifier ay nagbibigay-daan sa macro evaluation.
Ang pinakahuling tinukoy na mga detalye ng komento/string ay sinusuri muna. Mahalaga
tandaan: maaaring hindi lumabas ang mga komento sa pagitan ng pangalan ng isang macro at ng mga argumento nito (sa paggawa nito
nagreresulta sa hindi natukoy na pag-uugali).

Anumang bagay na hindi isang komento/string ay itinutugma sa isang posibleng meta-macro na tawag,
at kung nabigo rin iyon, laban sa isang posibleng user-macro na tawag. Sumasailalim ang lahat ng natitirang teksto
pagpapalit ng mga pagkakasunud-sunod ng sanggunian ng argumento ng nauugnay na teksto ng argumento (walang laman maliban kung
ang katawan na sinusuri ay ang kahulugan ng isang macro ng gumagamit) at pag-aalis ng quote
karakter kung meron man.

Tandaan na ang mga meta-macro na argumento ay ipinapasa sa meta-macro bago ang anumang pagsusuri
(bagama't maaaring piliin ng meta-macro na suriin ang mga ito, tingnan ang mga paglalarawan ng meta-macro sa ibaba).
Sa kaso ng #fashion meta-macro, pansamantalang nagdaragdag ang GPP ng isang detalye ng komento/string
upang paganahin ang pagkilala sa mga C string ("...") at maiwasan ang anumang pagsusuri sa loob ng mga ito, kaya hindi
panghihimasok ng mga character na inilalagay sa mga argumento ng C string sa #fashion sa
ang kasalukuyang syntax ay dapat katakutan.

Sa kabilang banda, ang mga argumento sa isang macro ng gumagamit ay sistematikong sinusuri, at pagkatapos
ipinasa bilang mga parameter ng konteksto sa katawan ng kahulugan ng macro, na nasusuri gamit iyon
kapaligiran. Ang tanging pagbubukod ay kapag ang kahulugan ng macro ay walang laman, kung saan ito ay
hindi sinusuri ang mga argumento. Tandaan na pansamantalang babalik ang GPP sa mode kung saan
ang macro ay tinukoy upang suriin ito, kaya perpektong ligtas na baguhin ang
operating mode sa pagitan ng oras na tinukoy ang isang macro at ang oras kung kailan ito tinawag.
Sa kabaligtaran, kung nais ng macro ng user na gumana sa kasalukuyang mode sa halip na sa mode na iyon
ay ginamit upang tukuyin ito kailangan itong magsimula sa a #fashion ibalik tawag at tapusin sa a #fashion
i-save ang tawagan

Maaaring tukuyin ang macro ng user gamit ang mga pinangalanang argumento (tingnan ang # tukuyin paglalarawan sa ibaba). Sa ganyan
kaso, kapag ang macro definition ay sinusuri, ang bawat pinangalanang parameter ay nagiging sanhi ng a
pansamantalang virtual user-macro na kahulugan na gagawin; ang naturang macro ay maaaring tawagin lamang
walang mga argumento at ibinabalik lamang ang teksto ng kaukulang argumento.

Tandaan na, dahil sinusuri ang mga macro kapag tinawag ang mga ito sa halip na kung kailan sila tinawag
tinukoy, ang anumang pagtatangka na tumawag sa isang recursive macro ay nagdudulot ng hindi natukoy na pag-uugali maliban sa
napaka partikular na kaso kapag ginagamit ng macro #undef upang burahin ang sarili pagkatapos ng finitely maraming loop
pag-ulit

Panghuli, ang isang espesyal na kaso ay nangyayari kapag ang isang user macro na ang kahulugan ay walang kasangkot
ang mga argumento (ni pinangalanang argumento o ang pagkakasunod-sunod ng sanggunian ng argumento) ay tinatawag sa a
mode kung saan walang laman ang maikling user-macro end sequence (hal, cpp o TeX mode). Sa ganyan
kaso ito ay ipinapalagay na isang bansag macro: ang mga argumento nito ay unang sinusuri sa kasalukuyang
mode gaya ng dati, ngunit sa halip na maipasa sa macro definition bilang mga parameter (na
magdudulot sa kanila na itapon) sila ay talagang idinagdag sa macro definition,
gamit ang syntax rules ng mode kung saan tinukoy ang macro, at ang resultang text
ay sinusuri muli. Samakatuwid, mahalagang tandaan na, sa kaso ng isang macro alias,
ang mga argumento ay aktwal na nasusuri nang dalawang beses sa dalawang potensyal na magkaibang mga mode.

META-MACROS

Ang mga macro na ito ay palaging paunang natukoy. Ang kanilang aktwal na pagkakasunud-sunod ng pagtawag ay depende sa kasalukuyang
mode; dito kami ay gumagamit ng cpp-like notation.

# tukuyin x y
Tinutukoy nito ang macro ng gumagamit x as y. y maaaring maging anumang wastong GPP input, at maaaring para sa
halimbawa sumangguni sa iba pang mga macro. x dapat ay isang identifier (ibig sabihin, isang pagkakasunod-sunod ng
mga alphanumeric na character at '_'), maliban kung tinukoy ang mga pinangalanang argumento. Kung x is
natukoy na, ang dating kahulugan ay na-overwrite. Kung walang pangalawang argumento ay
ibinigay, x ay tutukuyin bilang isang macro na walang output. hindi rin x ni y ay
sinusuri; ang macro definition ay sinusuri lamang kapag ito ay tinatawag, hindi kapag ito ay
ipinahayag.

Posible ring pangalanan ang mga argumento sa isang macro definition: sa kasong iyon, ang
argumento x dapat ay isang user-macro na tawag na ang mga argumento ay pawang mga identifier. Ang mga ito
nagiging available ang mga identifier bilang user-macros sa loob ng macro definition; ang mga ito
ang mga virtual na macro ay dapat na tawagan nang walang mga argumento, at suriin ang katumbas
macro parameter.

#defeval x y
Ito ay kumikilos sa katulad na paraan sa # tukuyin, ngunit ang pangalawang argumento y ay sinusuri
kaagad. Dahil sinusuri din ang mga macro definition ng user sa bawat oras na iyon
tinatawag, nangangahulugan ito na ang macro y sasailalim sa dalawa sunud-sunod na pagsusuri. Ang
kapakinabangan ng #defeval ay malaki dahil ito ang tanging paraan upang suriin ang isang bagay
higit sa isang beses, na maaaring kailanganin upang pilitin ang pagsusuri ng mga argumento ng isang meta-
macro na karaniwang hindi nagsasagawa ng anumang pagsusuri. Gayunpaman dahil ang lahat ng argumento
ang mga sanggunian na sinusuri sa define-time ay nauunawaan bilang mga argumento ng katawan sa
na tinutukoy ang macro at hindi bilang mga argumento ng macro mismo,
karaniwan ay kailangang gumamit ng quote character upang maiwasan ang agarang pagsusuri ng
mga sanggunian sa argumento.

#undef x
Inaalis nito ang anumang umiiral na kahulugan ng macro ng user x.

#ifdef x
Nagsisimula ito ng conditional block. Lahat ng kasunod ay susuriin lamang kung ang
pantukoy x ay tinukoy, at hanggang sa alinman sa a #iba o isang #endif naabot ang pahayag.
Tandaan, gayunpaman, na ang nagkomento na teksto ay na-scan pa rin ng maigi, kaya ang syntax nito
dapat may bisa. Ito ay partikular na legal na magkaroon ng #iba or #endif pahayag
ang pagtatapos sa conditional block ay lalabas lamang bilang resulta ng isang user-macro expansion
at hindi tahasan sa input.

#ifndef x
Nagsisimula ito ng conditional block. Lahat ng kasunod ay susuriin lamang kung ang
pantukoy x hindi nakalagay.

#ifeq x y
Nagsisimula ito ng conditional block. Lahat ng kasunod ay susuriin lamang kung ang
resulta ng mga pagsusuri ng x at y ay kapareho ng mga string ng character. Anuman
Ang nangunguna o sumusunod na whitespace ay binabalewala para sa paghahambing. Tandaan na sa cpp-mode
anumang hindi naka-quote na whitespace na character ay nauunawaan bilang katapusan ng unang argumento,
kaya kailangang mag-ingat.

#ifneq x y
Nagsisimula ito ng conditional block. Lahat ng kasunod ay susuriin lamang kung ang
resulta ng mga pagsusuri ng x at y ay hindi magkapareho (kahit hanggang sa pangunguna o
sumusunod na whitespace).

#iba I-toggle nito ang lohikal na halaga ng kasalukuyang conditional block. Ang sumusunod ay
sinusuri kung at kung ang naunang input ay na-comment out.

#endif Tinatapos nito ang isang conditional block na sinimulan ng a #kung... meta-macro.

# isama file
Nagiging sanhi ito ng GPP na buksan ang tinukoy na file at suriin ang mga nilalaman nito, na ipinapasok ang
nagreresultang teksto sa kasalukuyang output. Available pa rin ang lahat ng tinukoy na macro ng user
sa kasamang file, at kapalit ng lahat ng macro na tinukoy sa kasamang file ay
maging available sa lahat ng kasunod. Hinahanap muna ang kasamang file sa
ang kasalukuyang direktoryo, at pagkatapos, kung hindi natagpuan, sa isa sa mga tinukoy na direktoryo
sa pamamagitan ng -I opsyon sa command-line (o / usr / isama kung walang tinukoy na direktoryo).
Tandaan na, para sa mga dahilan ng pagiging tugma, posibleng ilagay ang pangalan ng file sa pagitan
"" o <>.

Ang pagkakasunud-sunod kung saan ang iba't ibang mga direktoryo ay hinanap kasama ang mga file ay
apektado ng -nostdinc, -nocurinc at -curdirinclast mga pagpipilian sa command-line.

Sa pagsama ng isang file, agad na nagse-save ang GPP ng kopya ng kasalukuyang operating mode
papunta sa stack ng mode, at ibinabalik ang operating mode sa dulo ng kasama
file. Maaaring i-override ng kasamang file ang gawi na ito sa pamamagitan ng pagsisimula sa a #fashion ibalik
tawag at nagtatapos sa a #fashion itulak tawag. Bukod pa rito, kapag ang -m command line
ang opsyon ay tinukoy, ang GPP ay awtomatikong lilipat sa cpp compatibility mode
sa pagsasama ng isang file na ang pangalan ay nagtatapos sa alinman sa '.c' o '.h'.

#exec utos
Nagiging sanhi ito ng GPP na isagawa ang tinukoy na command line at isama ang pamantayan nito
output sa kasalukuyang output. Tandaan na, para sa mga kadahilanang pangseguridad, ang meta-macro na ito ay
may kapansanan maliban kung ang -x ang flag ng command line ay tinukoy. Kung gumagamit ng #exec Hindi
pinapayagan, ang isang mensahe ng babala ay naka-print at ang output ay naiwang blangko. Tandaan na ang
ang tinukoy na command line ay sinusuri bago isagawa, kaya pinapayagan ang paggamit ng
macros sa command-line. Gayunpaman, ang output ng command ay kasama sa verbatim
at hindi nasusuri. Kung kailangan mong suriin ang output, dapat mong gamitin #defeval
(tingnan sa itaas) upang magdulot ng dobleng pagsusuri.

#eval ipahayag
Ang #eval meta-macro pagtatangka upang suriin ipahayag una sa pamamagitan ng pagpapalawak ng mga macro (normal
GPP evaluation) at pagkatapos ay sa pamamagitan ng pagsasagawa ng arithmetic evaluation at/o wildcard
tugma. Ang syntax at operator precedence para sa mga expression ng aritmetika ay ang
katulad ng sa C; ang tanging nawawalang mga operator ay <<, >>, ?:, at ang pagtatalaga
mga operator.

Ang POSIX-style wildcard na pagtutugma ('globbing') ay available lang sa POSIX
mga pagpapatupad at maaaring i-invoke gamit ang =~ operator. Sa madaling sabi, isang '?' mga posporo
anumang solong karakter, isang '*' ang tumutugma sa anumang string (kabilang ang walang laman na string), at
Ang '[...]' ay tumutugma sa alinman sa mga character na nakapaloob sa mga bracket. Ang isang '[...]' na klase ay
kinukumpleto kapag ang unang character sa mga bracket ay '!'. Ang mga tauhan sa a
Ang klase ng '[...]' ay maaari ding tukuyin bilang isang hanay gamit ang karakter na '-' -- hal,
Ang '[FN]' ay katumbas ng '[FGHIJKLMN]'.

Kung hindi makapagtalaga ng numerical value sa resulta, simple lang ang ibinalik na text
ang resulta ng macro expansion nang walang anumang arithmetic evaluation. Ang nag-iisang
Ang mga pagbubukod sa panuntunang ito ay ang mga operator ng paghahambing ==, !=, <, >, <=, at >=
na, kung ang isa sa mga panig ay hindi nagsusuri sa isang numero, magsagawa ng paghahambing ng string
sa halip (binalewala ang trailing at leading spaces). Bukod pa rito, ang haba(...)
Ibinabalik ng operator ng arithmetic ang haba sa mga character ng nasuri nitong argumento.

Sa loob ng arithmetic expression, ang tinukoy(...) espesyal na user macro ay din
magagamit: ito ay tumatagal lamang ng isang argumento, na hindi sinusuri, at nagbabalik ng 1 kung ito
ay ang pangalan ng isang user macro at 0 kung hindi man.

#kung ipahayag
Invokes ng meta-macro na ito ang arithmetic/globbing evaluator sa parehong paraan tulad ng
#eval at inihahambing ang resulta ng pagsusuri sa string na "0" upang masimulan ang a
conditional block. Sa partikular na tandaan na ang lohikal na halaga ng ipahayag ay laging totoo
kapag hindi ito masusuri sa isang numero.

#elif ipahayag
Ang meta-macro na ito ay maaaring gamitin upang maiwasan ang nested #kung kundisyon. #kung ... #elif ...
#endif ay katumbas ng #kung ... #iba #kung ... #endif #endif.

#fashion keyword ...
Kinokontrol ng meta-macro na ito ang operating mode ng GPP. Tingnan sa ibaba para sa isang listahan ng #fashion
utos.

#linya Sinusuri ng meta-macro na ito ang numero ng linya ng kasalukuyang input file.

#fillet Sinusuri ng meta-macro na ito ang filename ng kasalukuyang input file kung paano ito lumilitaw
sa command line o sa argumento sa # isama. Kung binabasa ng GPP ang input nito
mula sa stdin, pagkatapos #fillet sinusuri sa `stdin'.

#date fmt
Ang meta-macro na ito ay nagsusuri sa kasalukuyang petsa at oras bilang na-format ng
tinukoy na format na string fmt. Tingnan ang seksyon DATE AT TIME KONVERSYON MGA SPECIFIER
sa ibaba.

#error msg
Ang meta-macro na ito ay nagdudulot ng mensahe ng error na may kasalukuyang filename at numero ng linya,
at kasama ang text msg, na ipi-print sa karaniwang error device. Kasunod
pagpoproseso ay pagkatapos ay aborted.

# babala msg
Ang meta-macro na ito ay nagdudulot ng mensahe ng babala na may kasalukuyang filename at numero ng linya,
at kasama ang text msg, na ipi-print sa karaniwang error device. Kasunod
ang pagproseso ay pagkatapos ay ipinagpatuloy.

Ang susi sa flexibility ng GPP ay ang #fashion meta-macro. Ang unang argumento nito ay palaging isa sa
isang listahan ng magagamit na mga keyword (tingnan sa ibaba); ang pangalawang argumento nito ay palaging pagkakasunod-sunod ng
mga salitang pinaghihiwalay ng whitespace. Bukod sa posibleng una sa kanila, bawat isa sa mga salitang ito
ay palaging isang delimiter o syntax specifier, at dapat ibigay bilang isang C string delimited
sa pamamagitan ng dobleng panipi (" "). Ang iba't ibang espesyal na pagtutugma ng mga pagkakasunud-sunod na nakalista sa seksyon sa
Ang mga detalye ng syntax ay magagamit. Anuman #fashion Ang command ay na-parse sa isang mode kung saan ang "..." ay
naiintindihan na isang C-style string, kaya ligtas na ilagay ang anumang karakter sa loob ng mga ito
mga string. Tandaan din na ang unang argumento ng #fashion (ang keyword) ay hindi kailanman sinusuri,
habang sinusuri ang pangalawang argumento (maliban siyempre para sa mga nilalaman ng mga string ng C),
upang ang syntax specification ay maaaring makuha bilang resulta ng isang macro evaluation.

Ang magagamit #fashion ang mga utos ay:

#fashion i-save ang / #fashion itulak
Itulak ang kasalukuyang detalye ng mode sa stack ng mode.

#fashion ibalik / #fashion pop
Pagtutukoy ng pop mode mula sa stack ng mode.

#fashion pamantayan pangalan
Pumili ng isa sa mga karaniwang mode. Ang tanging argument ay dapat isa sa: default
(default na mode); cpp, C (cpp mode); tex, TeX (tex mode); html, HTML (html mode);
xhtml, XHTML (xhtml mode); prolog, Prolog (prolog mode). Ang pangalan ng mode ay dapat na
direktang ibinigay, hindi bilang isang C string.

#fashion gumagamit "s1" ... "s9"
Tukuyin ang macro syntax ng user. Ang 9 na argumento, lahat ng mga ito ay C string, ang mode
detalye para sa mga macro ng gumagamit (tingnan ang -U command-line na opsyon at ang seksyon sa
pagtutukoy ng syntax). Hindi apektado ang meta-macro na detalye.

#fashion meta {user | "s1" ... "s7"}
Tukuyin ang meta-macro syntax. Alinman ang tanging argumento ay gumagamit (hindi bilang isang string), at
ang mga detalye ng user-macro mode ay kinopya sa meta-macro mode
mga pagtutukoy, o dapat mayroong pitong string na argumento, na ang kahalagahan ay ang
katulad ng para sa -M command-line na opsyon (tingnan ang seksyon sa detalye ng syntax).

#fashion sipi ["c"]
Nang walang argumento o "" bilang argumento, inaalis ang quote character specification at
hindi pinapagana ang pag-andar ng pagsipi. Sa isang string argument, ang unang character
ng string ay kinuha na ang bagong quote character. Ang quote character ay maaaring
alinman sa alphanumeric o '_', at hindi rin ito maaaring isa sa mga espesyal na pagtutugma ng mga pagkakasunud-sunod.

#fashion puna [xxx] "simula" "katapusan" ["c" ["c"]]
Magdagdag ng detalye ng komento. Opsyonal ang isang unang argumento na binubuo ng tatlo
ang mga character na hindi nakapaloob sa " " ay maaaring gamitin upang tumukoy ng komento/string modifier
(tingnan ang seksyon sa detalye ng syntax). Ang default na modifier ay ccc. Ang unang
dalawang string argument ang ginagamit bilang simula at pagtatapos ng mga sequence ng komento ayon sa pagkakabanggit. Ang
Ang argumentong pangatlong string ay opsyonal at maaaring gamitin upang tukuyin ang isang string-quote
karakter. (Kung ito ay "", ang functionality ay hindi pinagana.) Ang ikaapat na string
Ang argumento ay opsyonal at maaaring gamitin upang tukuyin ang isang babala sa delimitation ng string
karakter. (Kung ito ay "", ang pagpapagana ay hindi pinagana.)

#fashion pisi [xxx] "simula" "katapusan" ["c" ["c"]]
Magdagdag ng detalye ng string. Kapareho ng #fashion puna maliban na ang default
modifier ay sss.

#fashion nocomment / #fashion nostring ["simula"]
Nang walang argumento, alisin ang lahat ng mga detalye ng komento/string. Sa isang string
argumento, tanggalin ang detalye ng komento/string na ang sequence ng pagsisimula ay ang
argumento.

#fashion preservelf { on | off | 1 | 0 }
Katumbas ng -n switch ng command-line. Kung ang argumento ay on or 1, anumang bagong linya
o whitespace na character na nagtatapos sa isang macro na tawag o isang komento/string ay naiwan sa
input stream para sa karagdagang pagproseso. Kung ang argumento ay off or 0 ang tampok na ito ay
may kapansanan

#fashion charset { id | op | pagkakapantay } "kuwerdas"
Tukuyin ang mga set ng character na gagamitin para sa pagtutugma ng espesyal na \o, \O at \i
mga pagkakasunod-sunod. Ang unang argumento ay dapat isa sa id (ang set ay tumugma sa \i), op (Ang
set na itinugma ng \o) o pagkakapantay (ang set na itinugma ng \O bilang karagdagan sa isa na itinugma ng
\o). "kuwerdas" ay isang C string na naglilista ng lahat ng mga character na ilalagay sa set. Maaaring
naglalaman lamang ng mga espesyal na pagtutugma ng mga pagkakasunud-sunod \a, \A, \b, \B, at \# (ang isa pa
mga sequence at ang mga negated sequence ay hindi pinapayagan). Kapag may nakitang '-'
sa pagitan ng dalawang hindi espesyal na character, idinaragdag nito ang lahat ng character sa pagitan (hal. "AZ"
tumutugma sa lahat ng malalaking titik). Upang magkaroon ng '-' sa katugmang set, alinman
ilagay ito sa una o huling posisyon o ilagay ito sa tabi ng isang \x sequence.

DATE AT TIME KONVERSYON MGA SPECIFIER

Ang mga ordinaryong character na inilagay sa string ng format ay kinokopya nang walang conversion.
Ang mga tagatukoy ng conversion ay ipinakilala ng isang `%' na character, at pinapalitan tulad ng sumusunod:

%a Ang pinaikling pangalan ng weekday ayon sa kasalukuyang lokal.

%A Ang buong pangalan ng weekday ayon sa kasalukuyang lokal.

%b Ang pinaikling pangalan ng buwan ayon sa kasalukuyang lokal.

%B Ang buong buwan na pangalan ayon sa kasalukuyang lokal.

%c Ang gustong representasyon ng petsa at oras para sa kasalukuyang lokal.

%d Ang araw ng buwan bilang isang decimal na numero (hanay 01 hanggang 31).

%F Katumbas ng %Y-%m-%d (ang format ng petsa ng ISO 8601).

%H Ang oras bilang isang decimal na numero gamit ang isang 24 na oras na orasan (hanay 00 hanggang 23).

%I Ang oras bilang isang decimal na numero gamit ang isang 12 na oras na orasan (hanay 01 hanggang 12).

%j Ang araw ng taon bilang isang decimal na numero (hanay 001 hanggang 366).

%m Ang buwan bilang isang decimal na numero (hanay 01 hanggang 12).

%M Ang minuto bilang isang decimal na numero (hanay 00 hanggang 59).

%p Alinman sa `AM' o `PM' ayon sa ibinigay na halaga ng oras, o ang katumbas
mga string para sa kasalukuyang lokal. Ang tanghali ay itinuturing bilang `pm' at hatinggabi bilang `am'.

%R Ang oras sa 24 na oras na notation (%H:%M).

%S Ang pangalawa bilang isang decimal na numero (hanay 00 hanggang 61).

%U Ang numero ng linggo ng kasalukuyang taon bilang isang decimal na numero, mula 00 hanggang 53,
simula sa unang Linggo bilang unang araw ng linggo 01.

%w Ang araw ng linggo bilang isang decimal, mula 0 hanggang 6, ang Linggo ay 0.

%W Ang numero ng linggo ng kasalukuyang taon bilang isang decimal na numero, mula 00 hanggang 53,
simula sa unang Lunes bilang unang araw ng linggo 01.

%x Ang ginustong representasyon ng petsa para sa kasalukuyang lokal na walang oras.

%X Ang ginustong representasyon ng oras para sa kasalukuyang lokal na walang petsa.

%y Ang taon bilang isang decimal na numero na walang isang siglo (saklaw ng 00 hanggang 99).

%Y Ang taon bilang isang decimal na numero kasama ang siglo.

%Z Ang time zone o pangalan o abbreviation.

%% Isang literal na `%' na character.

Depende sa C compiler at library na ginamit sa pag-compile ng GPP, maaaring magkaroon ng mas maraming conversion
available ang mga specifier. Kumonsulta sa dokumentasyon ng iyong compiler para sa strftime() function.
Tandaan, gayunpaman, na ang anumang mga specifier ng conversion na hindi nakalista sa itaas ay maaaring hindi portable sa kabuuan
mga pag-install ng GPP.

HALIMBAWA

Narito ang isang pangunahing maliwanag na halimbawa sa pamantayan o cpp mode:

#define FOO Ito ay
#define BAR ang isang mensahe.
#define concat #1 #2
concat(FOO,BAR)
#ifeq (concat(foo,bar)) (foo bar)
Ito ay output.
#iba
Hindi ito output.
#endif

Gamit ang pagpapangalan ng argumento, ang concat Ang macro ay maaaring matukoy bilang

#define concat(x,y) xy

Sa TeX mode at gamit ang pagpapangalan ng argumento, ang parehong halimbawa ay magiging:

\define{FOO}{Ito ay}
\define{BAR}{isang mensahe.}
\define{\concat{x}{y}}{\x \y}
\concat{\FOO}{\BAR}
\ifeq{\concat{foo}{bar}}{foo bar}
Ito ay output.
\iba
Hindi ito output.
\tapusin kung

Sa HTML mode at walang argumentong pagpapangalan, ang isa ay nakakakuha ng katulad na:

<#define FOO|Ito ay>
<#define BAR|isang mensahe.>
<#define concat|#1 #2>
<#concat <#FOO>|<#BAR>>
<#ifeq <#concat foo|bar>|foo bar>
Ito ay output.
<#else>
Hindi ito output.
<#endif>

Ang sumusunod na halimbawa (sa karaniwang mode) ay naglalarawan ng paggamit ng quote character:

#define FOO Ito ay \
isang multiline na kahulugan.
#define BLAH(x) Ang aking argumento ay x
BLAH(urf)
\BLAH(urf)

Tandaan na ang kahulugan ng multiline ay wasto din sa mga mode ng cpp at Prolog sa kabila ng
kawalan ng quote character, dahil ang '\' na sinusundan ng isang bagong linya ay binibigyang-kahulugan bilang a
komento at itinapon.

Sa cpp mode, ang mga C string at komento ay nauunawaan bilang ganoon, gaya ng inilalarawan ng
sumusunod na halimbawa:

#define BLAH foo
BLAH "BLAH" /* BLAH */
'Ito\'sa /*string*/ !'

Ang pangunahing pagkakaiba sa pagitan ng Prolog mode at cpp mode ay ang paghawak ng mga string at
mga komento: sa Prolog, ang isang '...' na string ay hindi maaaring magsimula kaagad pagkatapos ng isang digit, at isang /*...*/
maaaring hindi agad magsimula ang komento pagkatapos ng karakter ng operator. Higit pa rito, ang mga komento ay
hindi inalis mula sa output maliban kung nangyari ang mga ito sa isang #command.

Ang mga pagkakaiba sa pagitan ng cpp mode at default na mode ay mas malalim: sa default mode #commands
maaaring magsimula kahit saan, habang nasa cpp mode dapat sila ay nasa simula ng isang linya; ang default
mode ay walang kaalaman sa mga komento at string, ngunit may quote character ('\'), habang ang cpp
mode ay may malawak na komento/string na mga pagtutukoy ngunit walang quote character. Bukod dito, ang
ang mga argumento sa meta-macros ay kailangang wastong nakakulong sa default na mode, habang hindi ganoon
ang pagsusuri ay isinasagawa sa cpp mode.

Ginagawa nitong mas madali ang paglalagay ng mga meta-macro na tawag sa default mode kaysa sa cpp mode. Para sa
halimbawa, isaalang-alang ang sumusunod na HTML mode input, na sumusubok para sa availability ng
#exec utos:

<#ifeq <#exec echo blah>|blah
> #exec allowed <#else> #exec not allowed <#endif>

Walang katumbas na cpp mode, habang sa default na mode madali itong maisalin bilang

#ifeq (#exec echo blah
) (blah
)
\#exec pinapayagan
#iba
\#exec hindi pinapayagan
#endif

Upang ma-nest ang mga meta-macro na tawag sa cpp mode, kinakailangan na baguhin ang mode
paglalarawan, alinman sa pamamagitan ng pagbabago ng meta-macro call syntax, o mas eleganteng sa pamamagitan ng pagtukoy
isang tahimik na string at gamit ang katotohanan na ang konteksto sa simula ng isang nasuri
string ay isang bagong linya na character:

#mode string QQQ "$" "$"
#ifeq $#exec echo blah
$$blah
$
\#exec pinapayagan
#iba
\#exec hindi pinapayagan
#endif

Tandaan, gayunpaman, na ang mga komento/mga string ay hindi maaaring nested ("..." sa loob ng $...$ ay pupunta
undetected), kaya kailangang maging maingat sa kung ano ang isasama sa loob ng ganoong katahimikan
sinuri na string. Sa halimbawang ito, ang maluwag na meta-macro nesting na ipinakilala sa bersyon 2.1
ginagawang posible na gamitin ang sumusunod na mas simpleng bersyon:

#ifeq blah #exec echo -n blah
\#exec pinapayagan
#iba
\#exec hindi pinapayagan
#endif

Tandaan na ang mga macro na walang mga argumento ay talagang nauunawaan na mga alias kapag sila ay
tinatawag na may mga argumento, gaya ng inilalarawan ng sumusunod na halimbawa (default o cpp mode):

#define DUP(x) xx
#define FOO at sabi ko: DUP
FOO(blah)

Ang pagiging kapaki-pakinabang ng #defeval Ang meta-macro ay ipinapakita ng sumusunod na halimbawa sa HTML mode:

<#define APPLY|<#defeval TEMP|<\##1 \#1>><#TEMP #2>>
<#define <#foo x>|<#x> at <#x>>
<#APPLY foo|BLAH>

Ang dahilan kung bakit #defeval ay kailangan na, dahil ang lahat ay sinusuri sa isang solong pass,
ang input na magreresulta sa gustong macro call ay kailangang mabuo ng una
pagsusuri ng mga argumentong ipinasa sa APPLY bago masuri sa pangalawang pagkakataon.

Upang isalin ang halimbawang ito sa default na mode, kailangan ng isa na gumamit ng panaklong sa pagkakasunud-sunod
upang i-nest ang #defeval na tawag sa loob ng kahulugan ng APPLY, ngunit kailangang gawin ito nang wala
paglabas ng mga panaklong. Ang pinakamadaling solusyon ay

#define BALANCE(x) x
#define APPLY(f,v) BALANCE(#defeval TEMP f
TEMP(v))
#define foo(x) x at x
APPLY(\foo,BLAH)

Tulad ng ipinaliwanag sa itaas, ang pinakasimpleng bersyon sa cpp mode ay umaasa sa pagtukoy ng isang tahimik na sinusuri
string upang gampanan ang papel ng BALANCE macro.

Ang sumusunod na halimbawa (default o cpp mode) ay nagpapakita ng arithmetic evaluation:

#define x 4
Ang sagot ay:
#eval x*x + 2*(16-x) + 1998%x

#if tinukoy(x)&&!(3*x+5>17)
Ito ay dapat na output.
#endif

Upang matapos, narito ang ilang halimbawa na kinasasangkutan ng paglipat ng mode. Ang sumusunod na halimbawa ay
self-explanatory (nagsisimula sa default mode):

#mode push
#define f(x) xx
#mode karaniwang tex
\f{blah}
\mode{string}{"$" "$"}
\mode{comment}{"/*" "*/"}
$\f{urf}$ /* blah */
\define{FOO}{bar/* at ilan pa */}
\mode{pop}
f($FOO$)

Ang isang magandang halimbawa kung saan nagiging kapaki-pakinabang ang mode na tinukoy ng user ay ang GPP source ng dokumentong ito
(magagamit kasama ng pamamahagi ng source code ng GPP).

Ang isa pang kawili-wiling application ay piling pinipilit ang pagsusuri ng mga macro sa mga string ng C
kapag nasa cpp mode. Halimbawa, isaalang-alang ang sumusunod na input:

#define blah(x) "at sinabi niya: x"
blah(foo)

Malinaw na gusto ng isa ang parameter x upang mapalawak sa loob ng string. meron
ilang mga paraan sa paligid ng problemang ito:

#mode push
#mode nostring "\""
#define blah(x) "at sinabi niya: x"
#mode pop

#mode quote "`"
#define blah(x) `"at sinabi niya: x`"

#mode string QQQ "$$" "$$"
#define blah(x) $$"at sinabi niya: x"$$

Ang unang paraan ay napaka natural, ngunit may abala ng pagiging mahaba at
neutralisahin ang string semantics, upang magkaroon ng hindi nasuri na halimbawa ng 'x' sa
string, o isang paglitaw ng '/*', ay magiging imposible nang hindi gumagamit ng higit pa
contortions.

Ang pangalawang paraan ay bahagyang mas mahusay dahil ang lokal na presensya ng isang quote
Pinapadali ng karakter na kontrolin kung ano ang sinusuri at kung ano ang hindi, ngunit may
disbentaha na kung minsan ay imposibleng makahanap ng isang makatwirang karakter ng quote nang wala
kinakailangang baguhin nang malaki ang source file o ilakip ito sa loob ng a #fashion itulak/pop
bumuo. Halimbawa, ang anumang paglitaw ng '/*' sa string ay kailangang ma-quote.

Ang huling paraan ay nagpapakita ng kahusayan ng nasuri na mga string sa konteksto ng
piling pagsusuri: dahil ang mga komento/mga string ay hindi maaaring nested, anumang paglitaw ng '"' o
Ang '/*' sa loob ng '$$' ay nakakakuha ng output bilang plain text, gaya ng inaasahan sa loob ng isang string, at lamang
naka-enable ang macro evaluation. Tandaan din na may higit na kalayaan sa pagpili ng a
string delimiter kaysa sa pagpili ng isang quote character.

Simula sa bersyon 2.1, ang mga meta-macro na tawag ay maaaring ma-nest nang mas mahusay sa default, cpp
at Prolog mode. Pinapadali nitong gumawa ng bersyon ng user ng isang meta-macro, o sa
dagdagan ang isang counter:

#define myeval #eval #1

#define x 1
#defeval x #eval x+1

ADVANCED HALIMBAWA

Narito ang ilang halimbawa ng mga advanced na construction gamit ang GPP. Sila ay madalas na medyo awkward
at dapat ituring bilang ebidensya ng mga limitasyon ng GPP.

Ang unang halimbawa ay isang recursive macro. Ang pangunahing problema ay iyon (dahil sinusuri ng GPP
lahat) ang isang recursive macro ay dapat maging maingat tungkol sa paraan kung saan ang recursion ay
winakasan upang maiwasan ang hindi natukoy na pag-uugali (karamihan ng oras ay mag-crash lang ang GPP).
Sa partikular, umaasa sa a #if/#else/#endif construct to end recursion ay hindi posible
at nagreresulta sa isang walang katapusang loop, dahil ini-scan ng GPP ang mga macro call ng user kahit na sa
hindi nasuri na sangay ng conditional block. Ang isang ligtas na paraan upang magpatuloy ay halimbawa bilang
sumusunod (ibinigay namin ang halimbawa sa TeX mode):

\define{countdown}{
\if{#1}
# 1 ...
\define{loop}{\countdown}
\iba
Mag-donate.
\define{loop}{}
\tapusin kung
\loop{\eval{#1-1}}
}
\countdown{10}

Isa pang halimbawa, sa cpp mode:

#mode string QQQ "$" "$"
#define triangle(x,y) y \
$#if haba(y)
$#define iter$ $#endif
$ iter(x,*y)
tatsulok(20)

Ang sumusunod ay isang (sa kasamaang palad ay napakahina) na pagtatangka sa pagpapatupad ng functional
abstraction sa GPP (sa karaniwang mode). Pag-unawa sa halimbawang ito at kung bakit hindi ito magawa
mas simple ay isang ehersisyo na natitira sa mausisa na mambabasa.

#mode string "`" "`" "\\"
#define ASIS(x) x
#define SILENT(x) ASIS()
#define EVAL(x,f,v) SILENT(
#mode string QQQ "`" "`" "\\"
#defeval TEMP0 x
#defeval TEMP1 (
\#define \TEMP2(TEMP0) f
)
TEMP1
)TEMP2(v)
#define LAMBDA(x,f,v) SILENT(
#ifneq (v) ()
#define TEMP3(a,b,c) EVAL(a,b,c)
#iba
#define TEMP3(a,b,c) \LAMBDA(a,b)
#endif
)TEMP3(x,f,v)
#define EVALAMBDA(x,y) SILENT(
#defeval TEMP4 x
#defeval TEMP5 y
)
#define APPLY(f,v) SILENT(
#defeval TEMP6 ASIS(\EVA)f
TEMP6
)EVAL(TEMP4,TEMP5,v)

Nagbubunga ito ng mga sumusunod na resulta:

LAMBDA(z,z+z)
=> LAMBDA(z,z+z)

LAMBDA(z,z+z,2)
=> 2+2

#define f LAMBDA(y,y*y)
f
=> LAMBDA(y,y*y)

APPLY(f,blah)
=> blah*blah

APPLY(LAMBDA(t,tt),(tt))
=> (tt) (tt)

LAMBDA(x, APPLY(f,(x+x)),urf)
=> (urf+urf)*(urf+urf)

APPLY(APPLY(LAMBDA(x,LAMBDA(y,x*y)),foo),bar)
=> foo*bar

#define test LAMBDA(y,`#ifeq y urf
ikaw ay urf#else
y ay hindi urf#endif
`)
APPLY(test,urf)
=> urf ay urf

APPLY(test,foo)
=> ang foo ay hindi urf

Gumamit ng gpp online gamit ang mga serbisyo ng onworks.net