makepp - Online sa Cloud

PROGRAMA:

NAME

makepp -- Tugma ngunit pinahusay na kapalit para sa make

SINOPSIS

makepp [ -e ] [ -C dir ] [ -f makefile] [ -F makefile_or_dir ]
[ -j n] [ -k ] [ -m paraan ] [ --noremake-makefiles ]
[ --nowarn ] [ -q ] [ -R dir] [ --traditional-recursive-make ]
[ -v ] [ --bersyon ] [ VAR=halaga ... ] [ target ... ]

mpp [-mga pagpipilian] [ VAR=halaga ... ] [ target ... ]

DESCRIPTION

Makepp, isang build program na may ilang feature na nagbibigay-daan para sa maaasahang mga build at
mas simpleng build file, ay isang drop-in na kapalit para sa GNU make. Sinusuportahan nito ang halos lahat ng
syntax na sinusuportahan ng GNU, at maaaring gamitin sa mga makefile na ginawa ng mga utility tulad nito
bilang automake. Ito ay tinatawag na makepp (o gumawa ng++) dahil ito ay dinisenyo na may espesyal na suporta
para sa C++, na mula noon ay pinalawig sa iba pang mga wika tulad ng Swig o naka-embed na SQL. Gayundin
relasyon nito sa gumawa ay kahalintulad sa relasyon ng C++ sa C: ito ay halos 100%
backward compatible ngunit nagdadagdag ng ilang bagong feature at mas mahusay na paraan para magsulat
makefiles.

Ang Makepp ay pumasa sa isang malawak na test-suite, at ginagamit sa ilang malalaking proyekto. Kung mayroon kang
anumang mga isyu sa pinakabagong bersyon ng CVS, holler, at susubukan naming ayusin ito nang mabilis. Makepp
tumatakbo sa anumang bersyon ng Perl mula noong 5.8.

Ang mga sumusunod na manu-manong pahina ay naglalaman ng karagdagang impormasyon sa kung paano gamitin ang makepp:

Sangguni
Paano magsulat ng isang makefile. Ito ay kadalasang inilaan para sa isang taong may kaunti o walang
karanasan sa paggamit ng anumang pagpapatupad ng make.

Tutorial sa Compilation
Ano ang ginagawa ng Unix compilation commands.

Release Notes
Ano ang nagbago sa bawat paglabas.

Incompatibilities
Ano ang gumagana nang naiiba sa pagitan ng GNU make at makepp.

speedup
Iba't ibang mga tip para gawing mas mabilis ang makepp.

Pagganap ng Perl
Iba't ibang mga tip para sa paggawa ng Perl programming (sa loob ng iyong mga makefile at sa ibang lugar) pumunta
mas mabilis.

cookbook
Mabilis na sagot sa "Paano ko ...?" o "Ano ang pinakamahusay na paraan upang ...?"

FAQ Mabilis na sagot sa mga tanong na natitisod ng mga tao.

Bumuo ng Algorithm
Paano naiiba ang build algorithm ng makepp sa mga pangunahing paraan mula sa tradisyonal na paggawa.

Bumuo ng Cache
Ang build cache ay isang direktoryo na nag-iimbak ng mga resulta ng mga naunang build kung sakaling ito ay
kailangan muli sa parehong direktoryo, o sa isang hiwalay na build sa ibang direktoryo.

Build Check Methods
Paano nagpapasya ang makepp kung kailan bubuo.

Mga Builtin na Utos
Makapangyarihan, mahusay na mga utos na available saanman ang makepp 2.0 o mas bago.

Mga Builtin na Panuntunan
Para sa napakasimpleng mga programa, maaaring hindi mo na kailangan ng makefile! Ito ang mga builtin
rules na alam ni makepp.

Pagkakatugma
Saan at sa anong bersyon ng Perl makepp gumagana.

Pagpapalawak
Paano ka makakapagdagdag ng mga function sa makepp sa pamamagitan ng pagsulat ng sarili mong Perl code.

Pag-andar
Mga function para sa pagmamanipula ng teksto at iba pang mga layunin.

Mga Repository
Ang mga repositoryo ay isang pamamaraan na pinapasimple ang parehong variant na mga build at pinapanatili ang isang sentral
hanay ng mga mapagkukunan.

Batas
Pagtukoy ng mga panuntunan sa pagbuo ng mga file.

Mga sandbox
Paggamit ng mga sandbox upang mahati ang build.

Pag-scan
Paano nag-scan ang makepp para sa mga dependency tulad ng pagsama ng mga file.

Mga lagda
Paano nagpapasya ang makepp kapag nagbago ang mga file.

Pahayag
Mga karagdagang direktiba para makontrol ang makepp.

Variable
Paggamit ng mga variable upang gawing simple ang mga panuntunan.

makepp, mpp
Command line syntax ng pangunahing utility.

makeppclean, mppc
Isang mahusay na stand-alone na cleanup script upang alisin ang mga file na nabuo ng makepp.

makeppgraph, mppg
Isang stand-alone na utility upang graphical na pag-aralan ang mga dependency at ang mga dahilan para sa a
muling itayo

makeppinfo, mppi
Isang stand-alone na utility para madaling itapon ang build info na naaalala ng makepp tungkol sa bawat isa
file.

makepplog, mppl
Isang stand-alone na utility para pag-aralan ang mga dependency at ang mga dahilan para sa muling pagtatayo.

makeppreplay, mppr
Isang stand-alone na utility para ulitin ang mga bagay na ginawa ng makepp, ngunit mas mabilis.

Index
Lahat ng mga keyword, function at operator sa makepp.

Mga tampok
Awtomatikong pag-scan para sa isama ang mga file
Awtomatikong nag-scan ang Makepp para sa pagsasama ng mga file. Iniiwasan nito ang pangangailangan para sa mga tool tulad ng
makedepend. Gumagana ang scanner ng Makepp kahit na wala pa ang mga kasamang file ngunit
kailangang itayo. (Totoo ito kahit saan man sila nagmula sa isamang landas,
hindi tulad ng mga program na nakadepende sa opsyong "-MM -MG" ng gcc.) May nababaluktot na sistema ang Makepp
para sa paggawa nito na batay sa pag-scan sa build command; maaari mong iakma ito para sa
iba pang mga wika o bumuo ng mga command sa pamamagitan ng pagsusulat ng Perl subroutine.

Mas mahusay na sistema para sa mga hierarchical build
Ang Makepp ay may mas mahusay na sistema para sa paghawak ng mga build na kinasasangkutan ng maraming direktoryo at
maraming makefile. Ang tradisyonal na pamamaraan ay ang gumawa ng invoke mismo
recursively sa bawat direktoryo. Depende sa kung gaano kakomplikado ang interdependencies
ay, ilang recursive pass ang minsan kailangan. Ginagawa nitong napakaganda ng makefiles
kumplikado kung ginagarantiyahan nila ang isang tamang build. Ang tunay na problema ay iyon maliban kung
Ang mga dependencies ay walang halaga (hal., isang library file lang), halos imposible na
ipahayag ang tumpak na mga dependency ng mga target sa isang makefile sa mga tuntunin ng mga target mula sa
yung ibang makefile. Ang Unix make ay hindi sapat na matalino upang mapagtanto na ang isang target sa isa
nakadepende ang makefile sa isang file na isang target sa isang mas mababang antas na makefile; hindi ito maaaring tumagal
bumuo ng mga utos mula sa mas mababang antas na makefile habang sinusubukan nitong itayo ang target
ang upper-level makefile. Kaya ang karaniwang solusyon ay ang pagbuo ng lahat ng bagay na maaaring maging
na binuo gamit ang mga mas mababang antas ng makefile, umaasa na sapat iyon upang mabuo ang lahat
kailangan iyon para sa upper-level na makefile.

Ini-load ng Makepp ang lahat ng kinakailangang makefile nang sabay-sabay, kaya wala itong problema sa pagharap
mga sitwasyon kung saan ang isang file mula sa isang makefile ay nakasalalay sa isang file na ginawa ng ibang
makefile. Awtomatikong napupunta ang Makepp cd sa direktoryo na naglalaman ng makefile dati
pagpapatupad ng isang utos mula sa isang makefile, kaya ang bawat makefile ay maaaring isulat nang nakapag-iisa
nang walang kaalaman sa top-level na build directory. Ngunit kung ang pag-access sa ugat ng iyong
mahalaga ang build tree (hal. dahil doon naninirahan ang iyong isamang direktoryo),
maaari mong pangalanan ang makefile sa direktoryong iyon nang espesyal. Pagkatapos ay binibigyan ka ng makepp ng landas
sa direktoryo na iyon sa isang variable.

Maaari ding malaman ng Makepp kung saan wala ang lahat ng makefile para sa buong proyekto
na sinasabi, kung ang bawat makefile ay nasa parehong direktoryo bilang ang mga file na ito ay dapat na
gumawa. Maaari din nitong gawing simple ang mga makefile.

Para sa higit pang mga detalye sa pagbuo ng maraming direktoryo, tingnan ang "Mga tip para sa maramihang
mga direktoryo" sa makepp_cookbook.

Maaasahang wildcard
Ang mga makefile ay maaaring gumamit ng mga wildcard nang mapagkakatiwalaan, dahil ang mga wild card ay tumutugma sa alinman sa mga file na iyon
umiiral, or mga file na wala pa pero alam ni makepp kung paano bumuo. Kaya kahit para sa isang
program na may dose-dosenang mga module, ang iyong buong makefile ay maaaring basahin lamang ang isang bagay tulad ng
ito:

CXX = g++
CXXFLAGS = -g

%.o : %.c
$(CXX) $(CXXFLAGS) -c $(input) -o $(output)

my_program: *.o
$(CXX) $(inputs) -o $(output)

at ito ay gagana kahit na wala pa sa mga ".o" na file ang nagawa pa.

Maaasahang build: naaalala ang build command
Sinusubaybayan ng Makepp ang mga build command, upang kung magbago ang mga opsyon sa compilation, ang mga file
ay awtomatikong itinayong muli. Mahalaga ito para magarantiya ang mga tamang build. (Ang ideya na ito
ay kinuha mula sa "cons" utility ni Bob Sidebothem, na inilarawan sa Perl
Journal noong 1998 at available mula sa CPAN.)

Upang ilarawan kung bakit ito mahalaga, isaalang-alang ang sumusunod na kahulugan ng istraktura:

klase ABC {
intx;
#ifndef SPECIAL_OPTION
int y;
#endif
int z;
};

Ngayon ipagpalagay na nagpasya kang i-on ang opsyong "SPECIAL_OPTION" sa pamamagitan ng pagdaragdag
"-DSPECIAL_OPTION" sa command line. Ang isang recompilation ng lahat ay kailangan, ngunit
ang isang tradisyunal na Unix na gumawa ay hindi makakakita nito, at muling magko-compile ng mga source file
na talagang nagbago. Bilang resulta, isasama ang ilan sa iyong mga module
-DSPECIAL_OPTION, at ang iba ay hindi. Pagkatapos ng isang napaka-nakakabigo na sesyon ng pag-debug, ikaw
matutuklasan na ang kailangan lang gawin ay muling itayo ang lahat. Pagkatapos ay gagawin mo
sumpa gumawa at sana ay lumipat sa isang pinabuting pagpapatupad nito, tulad ng makepp. Sa
least, yun ang ginawa ko.

Bilang isa pang halimbawa, ipagpalagay na nagtatrabaho ka sa isang proyekto na medyo maayos
na-debug, kaya karaniwan itong pinagsama-sama sa "-O2". Ngayon tumakbo ka sa isang bug na kailangan mo
upang tingnan sa debugger. Ang code na pinagsama-sama sa pag-optimize ay mahirap suriin
sa debugger, kaya gusto mong i-compile muli ang iyong code para matingnan mo ito. Kung
ang iyong makefile ay naka-set up upang iimbak ang mga opsyon ng compiler sa karaniwang mga variable, maaari mo
gawin mo lang ito:

makepp CFLAGS=-g CXXFLAGS=-g

at malalaman ng makepp na ang command line ay nagbago para sa lahat ng mga module. Tapos nung
nahanap mo na ang iyong bug, i-type lang

makepp

at ito ay muling isasama sa pag-optimize. Hindi mo kailangang i-type ang "make clean" kung kailan
binago mo ang mga pagpipilian sa pagbuo.

Ang ilang mga makefile (hal., para sa Linux kernel) ay napupunta sa hindi kapani-paniwalang haba upang pilitin
recompilation kapag nagbago ang compile command. Sa makepp, inaalagaan
awtomatiko--wala kang kailangang gawin.

Maaasahang mga build: eksaktong pagtutugma ng lagda
Bilang default, hindi lang tinitiyak ng makepp na ang lahat ng mga target ay mas bago kaysa sa lahat
dependencies; kung papalitan mo ang isang dependency ng isang mas lumang file, alam ng makepp na mayroon ito
upang muling itayo ang target, dahil lang nagbago ang input file. Ito ay isa pa
mahalagang tampok upang magarantiya ang mga tamang build na kinuha mula sa "cons" na utility.

Mga kalkulasyon ng matalinong lagda
Ang ilang mga pagbabago sa mga source na file ay hindi talaga nangangailangan ng muling pagtatayo. Halimbawa, kung
magpalit ka lang ng linya ng komento, o kung mag-reindent ka ng ilang code, walang partikular
dahilan para pilitin ang isang compilation. Para sa C/C++ compilation, tinutukoy ng makepp kung a
Ang file ay nangangailangan ng recompilation sa pamamagitan ng pag-compute ng cryptographic checksum ng mga nilalaman ng file,
binabalewala ang mga komento at whitespace, sa halip na tingnan ang oras ng file.

Ito ay partikular na kapaki-pakinabang kung mayroon kang kasamang mga file na nabuo ng mga file na iyon
pagbabago, ngunit ang nabuong kasama ang mga file ay bihirang magbago. Kumbaga ikaw
magkaroon ng kumplikadong yacc grammar sa iyong programa, na may panuntunan sa pagbuo tulad nito:

y.tab.c y.tab.h: parser.y
yacc -d parser.y

Karaniwan, sa tuwing gumawa ka ng kahit isang maliit na pagbabago sa "parser.y", bawat file na iyon
depende sa "y.tab.h" ay dapat na muling itayo dahil ang oras ng file ng "y.tab.h" ay nagbago.
Gayunpaman, hindi talaga mababago ng karamihan sa mga pagbabago sa "parser.y" ang mga nilalaman ng "y.tab.h"
(maliban sa posibleng komento), kaya lahat ng recompilation na iyon ay hindi kailangan.

Mga Repository
Maaaring awtomatikong isama ng Makepp ang mga file mula sa ibang puno ng direktoryo (ang
"repository") sa kasalukuyang build tree kung kinakailangan. (Ang ideyang ito ay kinuha rin mula sa
ang "cons" program.) Ito ay may ilang kawili-wiling gamit:

Mga build ng variant
Ipagpalagay na kino-compile mo ang iyong program na may optimization on at debugging
off. Ngayon ay isang bug ang lumalabas at kailangan mong i-compile muli ang lahat gamit ang pag-debug
pinagana. Kapag nahanap mo na ang bug, gayunpaman, isasara mo ang pag-debug at
optimization back on, at sa karamihan ng paggawa ng mga program ay kailangan mong i-compile lahat
ang mga pinagmumulan muli, kahit na ang mga hindi nagbabago. Ang pamamaraan ay magiging hitsura
ganito:

% makepp CFLAGS=-O2 # Compile everything.
# oops, natuklasan ang bug dito
% makepp CFLAGS=-g # Muling kino-compile ang lahat.
gdb my_program
# ... hanapin ang bug
% makepp CFLAGS=-O2 # Muling kino-compile ang lahat sa pangatlong beses.

Sa makepp, maaari kang mag-cd lamang sa isang walang laman na direktoryo, at tukuyin ang iyong orihinal
direktoryo bilang isang imbakan. Ito ay lilikha ng mga bagong object file sa walang laman
direktoryo, habang iniiwan ang iyong mga lumang object file na buo. Ngayon ay mahahanap mo na ang bug
sa direktoryo na pinagsama-sama sa debug, ayusin ito sa iyong mga orihinal na mapagkukunan, at pagkatapos ay pumunta
bumalik sa iyong orihinal na direktoryo. Ngayon lang ang ilang mga file na talagang binago mo
kailangang i-recompile.

Ang buong pamamaraan ay magiging ganito:

% makepp CFLAGS=-O2 # Compile everything.
# oops, natuklasan ang bug dito
% mkdir debugging
% cd debugging
% makepp -R .. CFLAGS=-g # Mag-compile nang pinagana ang pag-debug, ngunit
# ilagay ang mga bagay sa debugging subdir.
% gdb my_program
# ... hanapin ang bug
% cd .. # Bumalik sa orihinal na direktoryo.
% makepp CFLAGS=-O2 # Nire-compile lang ang mga file na iyon
# na nagbago ka.

Ito ay maaaring maging isang napakalaking pagtitipid sa oras kung mayroong maraming mga module.

Development team na may mga karaniwang mapagkukunan
Ipagpalagay na mayroon kang isang pangkat ng mga developer na nagtatrabaho sa isang karaniwang hanay ng mga mapagkukunan. Bawat isa
ang developer ay gumagawa ng mga independiyenteng pagbabago, ngunit hindi kailangang magkaroon ng kopya ng
buong puno ng pinagmulan. Gamit ang mga repositoryo ng makepp, maaari kang magkaroon ng bawat developer
mga kopya lamang ng mga file na binago niya. Makepp ay awtomatikong at
pansamantalang lumikha ng mga simbolikong link para sa iba pang mga file na hindi nabago
sa kaukulang mga file sa repositoryo. Magagawa pa nito ito para sa object
mga file na umiiral sa repositoryo at hindi kailangang i-recompile sa
indibidwal na direktoryo ng developer.

Garantiyang tama ang mga panuntunan
Kung ang iyong mga panuntunan ay gumagawa ng isang bagay na hindi mo sinabi sa makepp, ang repositoryo
hindi alam ng mekanismong kunin ang mga bagay na iyon. Kaya isang bagay na normal na bumubuo
ngunit ang nabigo mula sa isang repositoryo ay nagsasabi sa iyo na ayusin ang iyong mga panuntunan.

Awtomatikong hinuha ng mga kinakailangang ".o" na file
Madalas na mahihinuha ng Makepp kung aling mga bagay ang talagang kinakailangan nang hindi
tahasang sinabi. Kung gagamitin mo ang feature na ito, kung kasama ang isa sa iyong source file
"xx.h", at mayroong isang file na tinatawag na "xx.o" na alam ni makepp kung paano gumawa, pagkatapos ay makepp
nagdaragdag ng "xx.o" sa command line ng link. Hindi ako gumagamit ng mga hindi nakabahaging aklatan ngayon sa marami
mga lugar kung saan ako dati, dahil ang makepp ay maaaring awtomatikong pumili ng mga module na kailangan ko.

Tamang pangangasiwa ng mga alias para sa mga direktoryo
Ang Makepp ay hindi malito sa pamamagitan ng malambot na mga link sa isang direktoryo o ng ibang kamag-anak
mga filename na tumutukoy sa parehong file. Ang lahat ng mga path ng direktoryo sa isang file ay kinikilala,
kabilang foo, ./foo, ../src/foo, /auto_mnt/somedisk/bob/src/foo, at
/users/bob/src/foo.

Mga filename na may mga espesyal na character
Maaaring suportahan ng Makepp ang mga filename na may mga colon o mga puwang o iba pang mga espesyal na character na
maging sanhi ng problema para sa tradisyonal na paggawa. Palibutan lamang ng mga quote ang filename. (Tingnan
"Mga espesyal na character" sa makepp_rules para sa mga detalye.)

Extensible textual substitution functions
Maaaring gumamit ang Makepp ng mga arbitrary na subroutine ng Perl para sa pagpapalit ng teksto sa makefile.
Kung kilala mo si Perl, hindi ka napipigilan sa lahat ng set ng builtin ng makepp
mga function ng textual manipulation.

Maaari mo ring isulat ang Perl code sa iyong makefile. Maaari mong manipulahin ang Make
mga variable na may buong kapangyarihan ng buong wika ng Perl. Tingnan ang makepp_variables para sa
mga detalye.

Pag-log ng mga desisyon sa pagbuo
Bilang default, ang makepp ay gumagawa ng isang log-file na makikita gamit ang makepplog, mppl na naglalaman ng a
paglalarawan ng bawat file na sinubukan nitong buuin, anong panuntunan ang ginamit para buuin ito, ano
ito ay nakasalalay sa, at (kung ang file ay itinayong muli) bakit. Ito ay maaaring maging lubhang kapaki-pakinabang para sa
nagde-debug ng makefile--kung nagtataka ka kung bakit nagpasya si makepp na buuin muli ang isang file, o bakit
hindi, maaari ka lamang tumingin sa log file kung saan ipinapaliwanag nito ang mga desisyon.

Pinahusay na suporta para sa parallel build
Sinusuportahan ng Makepp ang mga parallel na compilation, ngunit (hindi tulad ng iba pang gumawa ng mga pagpapatupad) ito
ay hindi paghaluin ang output mula sa magkahiwalay na mga proseso na tumatakbo nang sabay-sabay.

Mga kasingkahulugan para sa mga misteryosong variable
Sinusuportahan ng Makepp ang mas madaling tandaan na mga kasingkahulugan para sa mga misteryosong make variable na $@, $^, at
$<. Tingnan ang makepp_variables para sa mga detalye.

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