icmun - Online sa Cloud

PROGRAMA:

NAME

icmake - Isang pagpapanatili ng programa (gumawa) utility gamit ang a C-parang grammar

SINOPSIS

icmake [mga pagpipilian] pinagmulan[.im] [dest[.bim]] [-- [args]]

icmun bimfile

DESCRIPTION

Icmake(1) ay maaaring gamitin bilang isang alternatibo sa gumawa(1). Sa karaniwang mode ng operasyon nito, ito
tinatawag ang mga sumusunod na programa:

o icm-pp upang paunang iproseso ang icmake file

o icm-comp sa byte-code compile ang icmake s

o icm-exec upang isagawa ang byte-code file

Icmake nagbibigay-daan sa mga programmer na gumamit ng isang programming language (malapit na kahawig ng kilalang
C-programming language) upang tukuyin ang mga aksyon na kasangkot sa (komplikadong) programa
pagpapanatili. Para dito, icmake nag-aalok ng iba't ibang mga espesyal na operator pati na rin ng isang hanay ng suporta
mga function na napatunayang kapaki-pakinabang sa pagpapanatili ng programa.

Ang programa icmun(1) ay maaaring gamitin upang i-disassemble ang pinagsama-samang byte-code (.bim) na file. Icmun
ay pangunahing ginagamit para sa paglalarawan, edukasyon, at pag-debug.

Ang mga tradisyunal na make-utility ay muling mag-compile ng mga mapagkukunan kapag nabago ang mga file ng header. Nasa
konteksto ng C + + pagbuo ng programa ito ay madalas na isang masamang ideya, bilang pagdaragdag ng isang bagong miyembro sa a
Karaniwang hindi kailangan ng klase na i-compile mo muli ang mga pinagmumulan ng klase. Upang mahawakan ang klase
dependencies icmbuld(1) maaaring siyasatin KLASE mga file na maaaring magamit upang tukuyin ang mga dependency
sa mga klase. Bilang default, hindi binibigyang-kahulugan ang mga dependency ng klase. Sumangguni sa icmconf(7)
man-page para sa karagdagang detalye.

Opsyon

Icmake gumagamit ng mga sumusunod na file at opsyon:

o pinagmulan: icmake script source file (default na extension: .im).

o patutunguhan: binary icmake script file (default: `source'.bim, na tinatawag na `.bim file'
sa ibaba).

o --: icmake arguments separator separating icmake mga argumento mula sa mga argumentong naipasa
sa .bim filenl() mga pagtatalo: sumusunod na mga argumento -- ay ipinasa sa .bim file
as-is, at available mula sa listahan argv parameter na tinukoy bilang ang icmake
mga script pangunahin pangalawang parameter ng function (tingnan sa ibaba sa seksyon USER TINUTUKOY
Mga function). Para sa ilang mga opsyon (tingnan sa ibaba) ang -- hindi kailangan ang separator.

Icmake sumusuporta sa iba't ibang mga opsyon, na inilarawan sa susunod. Ang -h nilalampasan ng opsyon ang lahat ng iba pa
mga pagpipilian, ang -a pinapalampas ng opsyon ang lahat ng iba pang opsyon maliban sa -h. Sa natitirang aksyon
mga pagpipilian (-b, -c, -e, -ako, -p at -t) isa lamang ang maaaring tukuyin:

o -a
ipakita ang impormasyon tungkol sa icmake, pinawalang-bisa ng -h;

o -b
itinigil: gamitin ang opsyon -e sa halip;

o -c
ang icmake source file ay pinagsama-sama, pagbuo ng isang .bim file;

o -e
isagawa ang icmake .bim file, na ibinigay bilang icmakeunang file argument. Anumang karagdagang
ang mga argumento ay ipinapasa sa .bim file bilang-ay, at -- hindi dapat tukuyin;

o -F
ang mga filename at flag pati na rin ang isang pangkalahatang-ideya ng lahat ng mga aksyon na isasagawa ng
icmake ay ipinapakita sa karaniwang output stream;

o -h
magbigay ng impormasyon sa paggamit at wakas icmake;

o -i
ang unang argumento ay ang icmake source file, ang default na binary file ay
itinayo kung kinakailangan. Ang anumang karagdagang argumento ay ipinapasa sa .bim file
as-is, at -- hindi dapat tukuyin;

o -p
ang icmake ang source file ay na-preprocess lang, at ang preprocessed na file ay nakasulat
sa icmakeAng pangalawang file na argumento ni (bilang default `pinagmulan'.pim);

o -q
hindi pinansin, aalisin sa hinaharap icmake bersyon;

o -t
sumusunod na argumento -t ay ang pangalan ng pansamantalang .bim file, na aalisin
pagkatapos icmaketawag ni. Kailan . ay tinukoy bilang ang pangalan ng pansamantalang .bim file
pagkatapos ay ang default na pansamantalang direktoryo, na sinusundan ng icmake's process-id, na sinusundan ng
.bim Ginagamit.

Kasunod ng pangalan ng pansamantalang .bim file ang pangalan ng icmake source script
dapat tukuyin. Ang anumang karagdagang mga argumento ay ipinapasa sa .bim file bilang-ay, at
-- hindi dapat tukuyin; Pagkatapos itakda ang executable flag ng source script file
(chmod +x script), at binibigyan ito ng isang paunang linya tulad nito:

#!/usr/bin/icmake -t.

ang icmake maaaring direktang tawagan ang script:

script arg1 arg2

kung saan ang icmake script `script' ay isinasagawa habang tinatanggap nito ang
argumento script arg1 arg2.

o -T
ang pagpipiliang ito ay dapat ibigay sa pangalan ng isang direktoryo na ginagamit upang mag-imbak
pansamantalang mga file. Hal, kapag nag-compile ng isang icmake script, ang output ng icmakeNi
Ang preprocessor ay isang pansamantalang file na aalisin kapag lumabas. Bilang default / Tmp Ginagamit,
maliban na lamang kung / Tmp ay hindi isang masusulat na direktoryo, kung saan ang kasalukuyang gumagamit $ HOME
ginagamit ang direktoryo. Ang mga implicit na pansamantalang filename ay palaging nagsisimula sa process id ng
ang kasalukuyang icmake proseso.

o -v
magpakita icmakenumero ng bersyon ni, at pagtatapos icmake, pinawalang-bisa ng -h

Icmun:

bimfile: binary icmake script file.

PREPROCESSOR DIREKTO

Ang mga sumusunod na direktiba ng preprocessor ay magagamit:

o komento:
pamantayan C komento (lahat sa pagitan /* at */) pati na rin ang comment-to-end-of-line (all
sumusunod na mga nilalaman ng linya //) ay hindi pinapansin.

o Shell startup: Ang unang linya ng icmake-script ay maaaring magsimula sa #!landas, Kung saan
landas tumutukoy sa ganap na lokasyon ng icmake programa. Sa paggawa ng script
executable, maaari itong tawagan nang walang tahasang pagtawag icmake.

Hal, kung ang unang linya ng isang (maipapatupad) icmakefile 'icm' (nang walang extension)
naglalaman ng

#!/usr/bin/icmake -i

pagkatapos icm ay maaaring ibigay bilang isang utos, sa gayon ay isinasagawa

/usr/bin/icmake -i icm ...

Bilang kahalili,

#!/usr/bin/icmake -t /tmp/icm

maaaring gamitin, na nagreresulta sa pagpapatupad ng

#!/usr/bin/icmake -t /tmp/icm icm ...

Sa kasong ito, ang binary file ay tinanggal kapag lumabas.

o # isama "filename"
Ang file filename ay kasama sa lokasyon ng direktiba

o # isama
Ang file filename ay kasama sa lokasyon ng # isama direktiba; filename
ay hinanap sa mga direktoryo na pinaghihiwalay ng tutuldok na tinukoy ng IM kapaligiran
variable. Ang unang paglitaw ng filename sa mga direktoryo na tinukoy ng IM
environment variable ang ginagamit.

o # tukuyin pantukoy [kahulugan]
Ang teksto pantukoy ay papalitan ng depinisyon. Maaaring naglalaman ang kahulugan
mga sanggunian sa natukoy nang mga identifier, gamit ang ${identifier} pormat. Kung ang
${identifier} ay hindi pa natukoy (pa), ang teksto ${identifier} ay literal na iniingatan.
Para maiwasan ang infinite recursion nang hindi hihigit sa 100 ${identifier} pinapayagan ang mga kapalit.

Ang mga kahulugan ay magpapatuloy sa susunod na linya kung ang huling karakter sa isang linya ay a
backslash (\). (na hindi kasama sa kahulugan). Ang preprocessor
pinagsasama-sama ang double-quuted string, at double quoted string ay maaaring hindi sumasaklaw sa maramihang
mga linya. Maramihang mga blangko (sa labas ng double quoted string) sa mga kahulugan ay
kinontrata sa iisang blangkong espasyo.

Ang kahulugang sumusunod sa #define's ang identifier ay opsyonal. Kung aalisin, ang
macro ay tinukoy, kaya maaari itong magamit sa #if(n)def mga direktiba (tingnan sa ibaba), ngunit sila
ay hindi pinapalitan ng anumang teksto sa icmake mga pahayag ng code.

o #ifdef pantukoy
Kung ang pantukoy macro ay tinukoy ang susunod na bloke ng code (hanggang sa isang pagtutugma #iba
or #endif binasa ang direktiba) ay pinagsama-sama ng byte. Kung hindi, ang bloke ng code ay
hindi pinansin

o #ifndef pantukoy
Kung ang pantukoy macro noon hindi tinukoy ang susunod na bloke ng code (hanggang sa isang pagtutugma
#iba or #endif direktiba ay nakita) ay byte-compiled. Kung hindi, ang bloke ng
hindi pinapansin ang code.

o #iba
Nagwawakas a #ifdef at #ifndef direktiba, binabaligtad ang desisyon sa pagtanggap tungkol sa
ang sumusunod na code. Isa lang #iba direktiba ay maaaring iugnay sa #if(n)def
mga direktiba

o #endif
Tinatapos ang preprocessor block simula sa pagtutugma #ifdef, #ifndef or #iba
direktiba. Ang #endif direktoryo at ang pagtutugma nito #if(n)def direktiba dapat
tinukoy sa parehong file.

o #undef pantukoy
Alisin pantukoy mula sa hanay ng mga tinukoy na simbolo. Hindi ito nakakaapekto sa
espesipikasyon ng anumang naunang tinukoy na mga simbolo kung saan identifier's depinisyon
ay nagamit. Kung pantukoy hindi pa natukoy ang isang babala ay inilabas.

DATA MGA uRI

Icmake sumusuporta sa mga uri ng data na ito:

o ASCII katangian nagpapatuloy
Ang ASCII character constant ay binubuo ng isang character, na napapalibutan ng single o double
quotes. Mga solong character (hal, 'a') kumakatawan sa karakter mismo. Pamantayan
mga pagkakasunud-sunod ng pagtakas (hal., '\n') ay sinusuportahan at kumakatawan sa kanilang karaniwang na-convert
halaga (hal. '\n' kumakatawan sa halaga ng ascii 10 (decimal)). Hindi karaniwang pagtakas
mga pagkakasunud-sunod (hal. '\x') ay kumakatawan sa ascii character na sumusunod sa escape character
(kaya '\x' katumbas ng 'x'). Kinakatawan ng mga escape sequence na binubuo ng tatlong octal digit
ang ascii character na tumutugma sa octal value modulo 256 (hal., '\123').
Kinakatawan ng mga escape sequence na binubuo ng x na sinusundan ng dalawang hexadecimal digit
ang ascii character na tumutugma sa hexadecimal na halaga (hal, '\xa4').

o int
Mga integral na halaga, mula sa -0x8000 sa pamamagitan ng 0x7fff. int ang mga pare-pareho ay maaaring
tinukoy bilang mga decimal na numero (nagsisimula sa mga digit 1 hanggang 9), mga octal na numero
(nagsisimula sa 0, na sinusundan ng isa o higit pang mga octal na digit) mga numerong hexadecimal
(nagsisimula sa 0x, na sinusundan ng isa o higit pang hexadecimal digit) o ​​bilang ASCII
mga pare-pareho ng karakter.

o pisi
Mga variable ng teksto. Ang mga string constant ay nililimitahan ng double quotes. Maramihang string
Ang mga constant ay maaaring pinagsama-sama, ngunit ang isang solong string ay maaaring hindi sumasaklaw sa maramihang
mga linya. String constants na pinaghihiwalay ng white space lang (ibig sabihin, mga blangko, bagong linya,
komento) ay pinagsama at kumakatawan sa isang solong string na pare-pareho. Upang ipahiwatig ang isang
end-of-line sa isang string constant gamitin ang \n pagkakasunud-sunod ng pagtakas.

Magagamit din ang mga ASCII character constant na napapalibutan ng double quotes sa
arithmetic expression kung ang isa sa mga operand ay isang int. Ang nag-iisang karakter
pare-pareho ang string dapat maging isang pare-pareho, at hindi maaaring maging a pisi variable

Gayundin, ang mga ASCII character constant na napapalibutan ng mga solong quote ay maaaring gamitin sa
mga sitwasyon kung saan inaasahan ang isang string operand.

o listahan
Isang istraktura ng data na naglalaman ng isang serye ng mga indibidwal na naa-access pisi mga halaga. Kailan
Ang isang listahan ay naglalaman ng mga elemento, ang unang elemento nito ay ipinahiwatig ng index 0.

o walang bisa
Ginagamit sa mga kahulugan ng function upang ipahiwatig na ang function ay hindi nagbabalik ng a
halaga.

Maaaring tukuyin ang mga variable sa pandaigdigang antas gayundin sa anumang lokal na antas sa loob
mga function. Kapag tinukoy sa loob ng mga function, ang pamantayan C mga tuntunin sa saklaw at visibility
mag-apply. Hal, ang mga lokal na variable ay maaari lamang gamitin sa kanilang sarili o sa mas malalim na nested
block, ang kanilang visibility ay natatakpan sa mas malalim na nested blocks sa pamamagitan ng pagtukoy ng magkapareho
pinangalanang variable sa loob ng mas malalim na nested na mga bloke. Ang mga variable ay malakas na nai-type, at
hindi maaaring magkaroon ng uri walang bisa.

Maaaring masimulan ang mga variable kapag tinukoy ang mga ito. Ang mga inisyal ay mga expression, iyon
ay maaaring gumamit ng paunang o tinukoy ng user na mga function, mga pare-parehong halaga, at mga halaga ng mga variable na
makikita sa punto ng kahulugan.

PREDEFINE CONSTANTS

Ang mga sumusunod na constant ay paunang natukoy ng icmake. Ang lahat ay pare-pareho int mga halaga:

─────────────────────────────────
halaga ng simbolo na inilaan para sa
─────────────────────────────────
O_ALL 8 makelist
O_DIR 2 makelist
O_FILE 1 makelist
O_SUBDIR 4 makelist
─────────────────────────────────
OFF 0 echo
SA 1 echo
─────────────────────────────────
P_CHECK 0 system calls
P_NOCHECK 1 system call
─────────────────────────────────
S_IEXEC 32 stat
S_IFCHR 1 stat
S_IFDIR 2 stat
S_IFREG 4 na istatistika
S_IREAD 8 stat
S_IWRITE 16 na istatistika
─────────────────────────────────

Ang mga sumusunod na constant ay nakadepende sa arkitektura:

────────────────────────────────────────────────── ────────────
simbolo 1 kapag tinukoy sa platform, kung hindi 0
────────────────────────────────────────────────── ────────────
unix Unix, kadalasang may gcc compiler ng GNU
Maaaring maging available ang UNIX
linux x86 na tumatakbo sa Linux (karaniwan ay may gcc)
Maaaring maging available ang LINUX
M_SYSV, M_UNIX x86 na tumatakbo sa SCO/Unix
_POSIX _SOURCE Unix na may compiler na sumusunod sa Posix
__hpux HP-UX, kasama ang katutubong HP compiler
────────────────────────────────────────────────── ────────────

OPERATOR

int-typed (mga) operand:

lahat C magagamit ang mga operator (maliban sa mga operator ng pointer, bilang icmake ay hindi sumusuporta
mga payo). Nagpapatakbo sila tulad ng kanilang C-mga katapat na wika sa programming.

string-typed (mga) operand:

para pisi uri ng mga variable at/o constants ang mga sumusunod na operator ay magagamit (a at b
kumatawan pisi mga variable o constants):

o a + b: nagbabalik ng bago pisi halaga na naglalaman ng pagsasama-sama ng pisi halaga a
at b. Tandaan na pisi Ang mga constant ay maaaring direktang pinagsama-sama (nang hindi ginagamit ang +
operator), hal, ang sumusunod na dalawang linya ay parehong tumutukoy sa string "Kamusta mundo ":

"hello" "mundo"
"hello" + "world"

o a += b: a Dapat ay isang pisi variable, kung saan ang pisi variable o halaga b is
nakadugtong

o paghahambing ng string: mga operator == != <= >= < > != at == maaaring mailapat sa pisi
value o variable, ibinabalik ang 1 kung magtagumpay ang paghahambing, kung hindi ay 0.
Ang paghahambing ay case sensitive, at sumusunod sa pagkakasunud-sunod o mga character gaya ng tinukoy
nasa ASCII set ng karakter.

o !a: ang boolean ! (hindi) operator ay nagbabalik ng 1 kung ang pisi a ay walang laman, kung hindi 0 ay
bumalik.

o a mas bata pa b, a mas bago b: nagbabalik ng 1 kung file a ay mas bago kaysa sa file b. Hal,
"source.cc" mas bago "source.o". Ang mga papeles a at b hindi kailangang umiral: kung pareho ay hindi
ibinalik ang exist 0; kung b ay hindi umiiral, 1 ay ibinalik; kung a ay hindi umiiral 0 ay
ibinalik; kung pareho silang matanda 0 ay ibinalik. (ang umiiral() paunang natukoy na function
(tingnan sa ibaba, seksyon PREDEFINE Mga function) ay maaaring gamitin upang tahasang subukan kung a
umiiral ang file).

o a mas matanda b: nagiging 1 kung file a ay mas matanda kaysa sa file b. Hal, "libprog.a" mas matanda
"source.o". Ang mga papeles a at b hindi kailangang umiral: kung pareho ay hindi umiiral 0 ay
ibinalik; kung a ay hindi umiiral, 1 ay ibinalik; kung b ay hindi umiiral 0 ay ibinalik; kung
pareho silang matanda 0 ay ibinalik.

o []: ang index operator ay kumukuha ng isang character mula sa isang string variable o pare-pareho: ito
nagbabalik ng isang string bilang isang rhalaga. Samakatuwid, ang sumusunod na pahayag ay pinagsama ang OK:

// ipagpalagay na ang str1 at str2 ay mga string
str1 = str2[3];

ngunit ang sumusunod na pahayag ay hindi mag-compile:

str2[3] = "a";

Ibinabalik ang isang walang laman na string kung may ibinigay na di-wastong halaga ng index.

o Ang operator ng `backtick` (`kuwerdas cmd`)
Ang isang string na inilagay sa pagitan ng dalawang backtick ay pinaandar ng popen(3) function. Ang
karaniwang output gererated sa pamamagitan ng command na naka-imbak sa string argument ay
ibinalik bilang isang listahan. Ang isang walang laman na listahan ay nagpapahiwatig na ang utos ay hindi maisakatuparan.
Ang isang utos na maaaring isagawa ngunit hindi gumawa ng anumang output ay nagbabalik ng isang listahan
naglalaman ng isang walang laman na elemento. Ang karaniwang error stream output ng command ay hindi
kinolekta ng operator ng backtick. Gayunpaman, maaaring ang karaniwang pag-redirect ng shell
ginamit upang kolektahin ang output ng karaniwang error stream. Halimbawa:

printf(`"ls"`); // nagpi-print ng mga elemento sa
// ang kasalukuyang direktoryo

Ang paunang natukoy na function eval(string cmd) kumilos nang eksakto tulad ng backtick
operator: magkasingkahulugan sila.

list-typed (mga) operand:

para listahan uri ng mga variable at/o mga halaga ang mga sumusunod na operator ay magagamit:

o a + b: nagbabalik ng bago listahan halaga na naglalaman ng pagsasama-sama ng listahan halaga a at
b. Ito ay hindi isang set na operasyon: kung ang isang elemento ay lilitaw pareho sa a at sa b, sila ay mag
lalabas nang dalawang beses sa resultang listahan (set-addition ay ibinigay ng built-in
tungkulin pakikinig).

o a - b: nagbabalik ng bago listahan halaga na naglalaman ng mga elemento sa a na wala
in b. ito is isang set-difference operation: ang ibinalik na listahan ay naglalaman ng lahat ng elemento
in a na hindi mga elemento ng b.

o a += b: mga elemento sa b ay idinagdag sa mga elemento sa a, na dapat ay a listahan
variable. Ito ay hindi isang set na operasyon.

o a -= b: mga elemento sa b ay tinanggal mula sa mga elemento sa a, na dapat ay a listahan
variable. Ito is isang set na operasyon: lahat ng elemento ng a na matatagpuan sa b ay
tinanggal mula sa a.

o ilista ang mga paghahambing ng pagkakapantay-pantay: mga operator != at == maaaring mailapat sa listahan halaga o
mga variable. Operator == nagbabalik ng 1 kung ang parehong mga listahan ay may magkatulad na elemento sa bawat elemento
elemento, kung hindi, 0 ang ibinalik. Operator != binabaligtad ang resulta ng ==.

o !a: ang boolean ! operator ay nagbabalik ng 1 kung ang listahan a ay walang laman, kung hindi 0 ay
bumalik.

o []: kinukuha ng index operator ang isang elemento ng listahan mula sa isang variable ng listahan: nagbabalik ito ng a
string bilang isang rhalaga. Samakatuwid, ang sumusunod na pahayag ay pinagsama ang OK:

// ipagpalagay na ang lst ay isang listahan, ang str ay isang string
str = lst[3];

ngunit ang sumusunod na pahayag ay hindi mag-compile:

lst[3] = str;

Ibinabalik ang isang walang laman na string kung may ibinigay na di-wastong halaga ng index.

Casting:

Maaaring isagawa ang mga type-cast gamit ang pamantayan C cast-operator upang i-cast:

o Strings sa ints at vice versa ((int)"123", (kuwerdas)55)

o Mga string sa mga listahan (listahan Lst = (listahan)"hello")

Daloy Kontrol

Icmake nag-aalok ng sumusunod na subset ng Cmga pahayag ni. Maaari silang magamit tulad ng sa C
programming language.

o pagpapahayag ;
Ang plain expression na pahayag;

o Ang tambalang pahayag
Ang mga variable ng anumang uri ay maaaring tukuyin at simulan kahit saan sa loob ng anumang compound
pahayag. Ang pagiging tanaw ng isang variable ay nagsisimula sa punto ng kahulugan nito.

o if (kondisyon) pahayag
Sa loob ng kondisyon ang isang variable ay maaaring tukuyin at simulan. Hal,

kung (string str = getText())
proseso(str);

Sa halimbawang ito, paraan ay hindi tinatawag kung getText () nagbabalik ng walang laman na string. Ang
nagbabago STR ay hindi umiiral bago o pagkatapos ng if pahayag.

o if (kondisyon) pahayag iba pahayag
Tulad ng naunang pahayag, sa loob ng kundisyon ay maaaring tukuyin ang isang variable at
pinasimulan.

o para (sa loob; kalagayan; pagtaas) pahayag
Ang mga variable (ng iisang uri) ay maaaring masimulan (at opsyonal na tukuyin) sa
sa loob seksyon Ang sa loob, kalagayan at pagtaas maaaring manatiling walang laman ang mga seksyon. Ang
Ang seksyong walang laman na kondisyon ay binibigyang kahulugan bilang `palagi totoo'.

o habang (kondisyon) pahayag
Sa loob ng kondisyon ang isang variable ay maaaring tukuyin at simulan.
Isang pantulong do ... habang() hindi magagamit ang pahayag. Tandaan na ang pagtukoy sa a
variable, gamit ang pagpasimula ng expression ay nangangahulugan na ang initialization
ang pagpapahayag ay isinasagawa sa bawat pag-ulit ng habang pahayag. Kaya ang mga sumusunod
hindi magtatapos ang pahayag, at magpapakita ng walang katapusang stream ng mga halaga 10:

habang (int x = 10)
printf(x--, "\n");

o bumalik;, at pagbabalik pagpapahayag;
payak pagbabalik maaaring gamitin ang mga pahayag sa walang bisa mga function, at pagbabalik pagpapahayag
ang mga pahayag ay ginagamit sa ibang uri ng mga function. Ang function pangunahin may uri ng pagbabalik
walang bisa at iba pa pangunahin payak lang pagbabalik maaaring gamitin ang mga pahayag. Bilang default an icmake
ang exit value ng script ay katumbas ng 0. Gamitin ang built-in na function lumabas (tingnan sa ibaba) upang tukuyin
anumang iba pang exit value.

Be pinayuhan: ang pag-uugali ng mga non-void function na hindi nagbabalik ng mga halaga ay hindi natukoy.

o masira
Umalis para at habang mga pahayag, na sumasalungat sa kondisyon ng pahayag.

o magpatuloy
Nagpapatuloy sa susunod na pag-ulit ng a para or habang pahayag.

o exit(expression)
Tinatapos ang pagpapatupad ng isang icmake-script. Ang pagpapahayag dapat suriin sa isang int
value, na nagiging exit value ng script.

PREDEFINE Mga function

Icmake nag-aalok ng mga sumusunod na paunang natukoy na mga function, na maaaring gamitin saanman sa icmake
mga script. Ang sumusunod na pangkalahatang-ideya ay inayos ayon sa alpabeto ayon sa pangalan ng function.

o walang bisa arghead(string h)
Helper function ng exec() (tingnan din sa ibaba sa exec()): tumutukoy sa `ulo ng argumento',
gagamitin sa exec(). Bilang default, ang `argument head' ay isang walang laman na string.

o walang bisa argtail (string t)
Helper function ng exec() (tingnan din sa ibaba sa exec()): tumutukoy sa `buntot ng argumento',
gagamitin sa exec(). Bilang default, ang `argument tail' ay isang walang laman na string.

o int ascii (string s)
Ibinabalik ang unang karakter ng s bilang isang int; hal, ascii("A") nagbabalik ng 65;

o pisi ascii (int i)
Kita i bilang isang string, hal, ASCII(65) ibinabalik ang string "TO";

o pisi change_base(string file, pisi newbase)
Binabago ang basename ng file, ibinabalik ang binagong pangalan. Hal,
change_base("/path/demo.im", "labas") Babalik "/path/out.im";

o pisi change_ext(string file, pisi newext)
Binabago ang extension ng file, ibinabalik ang binagong pangalan. Hal,
rss_changeExt("source.cc", "o") Babalik "source.o";

o pisi change_path(string file, pisi bagong landas)
Binabago ang detalye ng path ng file, ibinabalik ang binagong pangalan. Hal,
change_path("tmp/binary", "/ usr / bin") Babalik "/usr/bin/binary". Tandaan na ang
/-Ang separator ay ipinapasok kung kinakailangan.

o pisi chdir(string newdir)
Binabago ang gumaganang direktoryo ng script, ibinabalik ang nakaraang dir bilang ganap
landas.

paggamit chdir("") para makuha ang kasalukuyang working directory, chdir("") maaaring magamit sa
makuha ang startup working directory (nasira ang functionality na ito sa mga release
bago ang 7.00, ngunit ngayon ay gumagana). Tinatapos ng function ang
icmake-script kung ang tinukoy newdir ay hindi umiiral.

o pisi chdir(int pagsuri, pisi newdir)
Parehong pag-andar tulad ng nakaraang pag-andar, ngunit sa pamamagitan ng pagtukoy pagsuri as
P_NOCHECK. hindi wawakasan ng function ang script. Sa halip, ibabalik nito ang
kasalukuyang gumaganang direktoryo ng script.

o cmdhead(string h)
Helper function ng exec() (tingnan din sa ibaba sa exec()): Tinutukoy ang isang `command head', sa
gamitin sa exec(). Bilang default, ang `command head' ay isang walang laman na string.

o cmdtail(string t)
Helper function ng exec() (tingnan din sa ibaba sa exec()): Tinutukoy ang isang `command tail', sa
gamitin sa exec(). Bilang default, ang `command tail' ay isang walang laman na string.

o echo(int opt)
Kinokontrol ang pag-echo ng mga tinatawag na programa (at ang kanilang mga argumento), tukuyin PATAY kung umaalingawngaw
ay hindi hinihiling. Bilang default echo(ON) Ginagamit.

o pisi elemento (int index, listahan (O string) var)
Mga kilos na kapareho ng index operator: sumangguni sa index ([]) operator sa
seksyon OPERATOR.

o listahan eval(string str)
Ang function na ito ay gumaganap nang kapareho sa backtick operator. Ang halimbawang ibinigay sa
ang backtick operator samakatuwid ay maaaring naisulat din ng ganito:

printf(eval("ls")); // nagpi-print ng mga elemento sa kasalukuyang
// direktoryo

o exec(string cmd, ...)
Nagsasagawa ng utos na may mga argumento. Ang bawat argumento ay lagyan ng prefix ng arghead()Ni
argumento at postfixed ni argtail()argumento ni. Tandaan na walang ipinapasok na mga blangko
sa pagitan ng arghead()ang mga nilalaman ni, ang tamang argumento, at argtail()argumento ni. Lahat
kaya ang mga binagong argumento ay pinagsama-sama, sa pagkakataong ito ay pinaghihiwalay ng mga solong blangko, at
pagkatapos cmdhead()Ang mga nilalaman ni ay ipinasok sa pagitan ng utos at ng unang argumento
(sa magkabilang panig na nililimitahan ng mga solong blangko) at cmdtail()Ang mga nilalaman ni ay nakadugtong
sa mga argumento (muli, pinaghihiwalay ng isang blangko). PATH ay hinahanap upang mahanap
cmd. 0 ay ibinalik.

o exec(int checkcmd, pisi cmd, ...)
Parehong pag-andar tulad ng nakaraang pag-andar, ngunit sa pamamagitan ng pagtukoy pagsuri as
NOT_CHECKED hindi wawakasan ng function ang script. Sa halip, ibabalik nito ang
tinatawag na exit status ng command, o 0x7f00 kung ang utos ay hindi natagpuan.

o isagawa (string cmd, pisi cmdhd, pisi arghd, ..., pisi argtl, pisi cmdtl)
Katulad ng exec(), ngunit kailangang tukuyin ang command head/tail at argument head/tail.

Ang aktwal na naisakatuparan na utos ay nagsisimula sa cmd, na sinusundan ng cmdhd. Susunod ay isang serye
ng mga argumento ang sumusunod, bawat isa ay nakapaloob sa arghd at argtl. Ang utos ay nagtatapos sa
cmdtl. 0 ay ibinalik

o isagawa (int pagsuri, pisi cmd, pisi cmdhd, pisi arghd, ..., pisi argtl,
pisi cmdtl)
Parehong pag-andar tulad ng nakaraang pag-andar, ngunit sa pamamagitan ng pagtukoy pagsuri as
NOT_CHECKED hindi wawakasan ng function ang script. Sa halip, ibabalik nito ang
tinatawag na exit status ng command, o 0x7f00 kung ang utos ay hindi natagpuan.

o int umiiral (string file)
Nagbabalik ng hindi zero na halaga kung file umiiral, kung hindi, 0 ay ibinalik.

o listahan fgets(string file, listahan offset)
TANDAAN: in icmake bersyon 8.00.00 ang prototype ng function na ito ay binago mula sa
listahan fgets(string file, int offset) sa listahan fgets(string file, listahan offset).

Ang susunod na linya na makikita sa offset na nasa ginalaw ay binabasa mula sa file. Ipasa ang isang
walang laman na listahan sa fgets upang basahin file sa simula nito.

Ibinabalik nito ang isang listahan na naglalaman bilang unang elemento ng mga nilalaman ng nabasang linya
(nang wala ang \n line terminator), bilang pangalawang elemento nito ang terminator ng linya `\n'
(kung nakatagpo), at bilang ikatlong elemento nito ang string OK kung matagumpay ang isang linya
basahin, Mabigo kung nabigo ang pagbabasa mula sa file. Kapag nagbabasa sa EOF isang walang laman na listahan
ibinalik. Ang ibinalik na listahan ay maaaring maglaman ng mga karagdagang elemento, na nasa loob
ginamit ni fgets kapag binabasa ang susunod na linya.

Upang magbasa ng maraming linya, magsimula sa pamamagitan ng pagpasa ng isang walang laman na listahan bilang nakakakuha ng pangalawang argumento.
Upang basahin ang mga kasunod na linya, ipasa ang naunang ibinalik na listahan sa mga fgets pangalawa
argumento.

Narito ang isang halimbawa na nagpapakita kung paano basahin ang isang kumpletong file:

listahan ret;
habang (1)
{
ret = fgets("filename", ret);
kung (!ret)
masira;
proseso(ret[0], ret[1]);
}

o int fprintf(string filename, ...)
Idinaragdag ang lahat ng (pinaghihiwalay ng kuwit) na argumento sa file filename. Ibinabalik ang bilang ng
nakalimbag na mga argumento.

o int fprintf(string filename, pisi format, ...)
Idinaragdag ang lahat ng (pinaghihiwalay ng kuwit) na argumento sa file filename. Ibinabalik ang bilang ng
nakalimbag na mga argumento.

If format naglalaman ng mga placeholder %1 .. %n ang output ay naka-format (tingnan din
strformat). Tandaan na sa kasong ito ang pagbibilang ng argumento (din) ay nagsisimula nang lampas sa
format string: ang unang argumento na sumusunod format ay tinutukoy bilang %1.

o pisi get_base(string file)
Ibinabalik ang base na pangalan ng file. Ang base name ay ang file na walang path prefix nito
at walang extension nito. Ang extension ay ang lahat ng impormasyon na nagsisimula sa pangwakas
tuldok sa filename. Kung walang nakitang pangwakas na tuldok, ang pangalan ng file ay ang batayang pangalan.
Hal, ang batayang pangalan ng ab katumbas ng a, ang batayang pangalan ng abc katumbas ng ab, ang base
pangalan ng a/b/c katumbas ng c.

o pisi getch()
Ibinabalik ang susunod na pinindot na key bilang isang string (hindi kinakailangan ang pagpindot sa `Enter').

o pisi get_dext(string file)
Ibinabalik ang extension ng file, kasama ang naghihiwalay na tuldok. Ang extension ay lahat
impormasyon na nagsisimula sa panghuling tuldok ng filename.

Kung walang makitang pangwakas na tuldok, isang walang laman na string ang ibabalik.

o listahan getenv(string envvar)
Ibinabalik ang halaga ng variable ng kapaligiran envvar sa isang listahan na naglalaman ng dalawang elemento:

ang unang elemento ay nagpapahiwatig kung ang variable ng kapaligiran ay tinukoy (value
"1") o hindi (value "0");
ang pangalawang elemento ay nagpapahiwatig ng halaga ng variable ng kapaligiran.

Ang mga variable ng kapaligiran ay nasa anyo variable=halaga, at kung tinukoy ang listahan ng
naglalaman ang pangalawang elemento halaga. Kung ang halaga ay walang laman, ang variable ay tinukoy, ngunit
walang text na nauugnay dito.

o pisi get_ext(string file)
Ibinabalik ang extension ng file, maliban sa naghihiwalay na tuldok. Ang extension ay lahat
impormasyon na nagsisimula sa huling tuldok sa filename.

Kung walang makitang pangwakas na tuldok, isang walang laman na string ang ibabalik.

o int getpid()
Ibinabalik ang process-id ng icmake byte code interpreter icm-exec.

o pisi makakakuha ng()
Ibinabalik ang susunod na linyang binasa mula sa keyboard bilang a pisi. Pumasok ang linya sa
Ang keyboard ay dapat wakasan ng isang `Enter' key, na hindi nakaimbak sa ibinalik
string.

o pisi get_path(string file)
Ibinabalik ang path-prefix ng file. Ang path prefix ay ang lahat ng impormasyon hanggang sa (at
kasama) ang panghuling separator ng direktoryo (na, depende sa pagpapatakbo
system, isang forward- o backslash).

Kung walang mahanap na landas, ibabalik ang isang walang laman na Strring.

o int listfind(listahan una, pisi str)
Ibinabalik ang unang index sa Lst kung saan ang string STR ay matatagpuan, o -1 kung Lst hindi
may STR.

o int makinig(listahan l)
Ibinabalik ang bilang ng mga elemento sa listahan.

o listahan listunion(listahan lhs, listahan rhs)
Nagbabalik ng listahang naglalaman ng pagsasama-sama ng mga elemento sa lhs at rhs.

o listahan listunion(listahan una, pisi str)
Nagbabalik ng listahang naglalaman ng pagsasama-sama ng mga elemento sa Lst at STR.

o listahan makelist(string maskara)
Nagbabalik ng listahan ng lahat ng file na tumutugma mask. Hal, makelist("*.c") nagbabalik ng listahan
naglalaman ng lahat ng mga file na nagtatapos sa .c.

o listahan makelist(uri, pisi maskara)
Pareho sa nakaraang function, ngunit ang uri ng mga elemento ng direktoryo ay maaaring
tinukoy bilang unang argumento nito:

kahulugan ng simbolo
IS_ALL makuha ang lahat ng mga entry sa direktoryo
IS_DIR makuha ang lahat ng mga direktoryo, kabilang ang . at ..
IS_FILE kumuha ng listahan ng mga file
IS_SUBDIR makuha ang lahat ng mga subdirectory

Tandaan na ang pattern * ay hindi tutugma sa mga nakatagong entry sa ilalim ng Unix-type na operating
mga sistema. Gamitin .* para sa na.

o listahan makelist(string maskara, mas bago, pisi comparefile)
Ibinabalik ang listahan ng lahat ng file na tumutugma sa mask na mas bago kaysa sa ibinigay
comparefile. Operator mas bata pa maaaring gamitin sa halip na mas bago. Tandaan na mas bago at
mas bata pa ay mga operator, hindi mga string.

o listahan makelist([int = IS_FILE,] pisi maskara, mas bago, pisi comparefile)
Pareho sa nakaraang function, ngunit uri maaaring tukuyin tulad ng sa listahan makelist(uri,
pisi maskara).

o makelist(string maskara, mas matanda, pisi comparefile)
Tingnan sa itaas; nagbabalik ng listahan ng mga file na mas luma kaysa sa comparefile.

o makelist(uri, pisi maskara, mas matanda, pisi comparefile)
Pareho sa nakaraang function, ngunit uri maaaring tukuyin tulad ng sa listahan makelist(uri,
pisi maskara).

o int printf(...)
Ipinapakita ang lahat ng (pinaghihiwalay ng kuwit) na argumento sa screen (ibig sabihin, ang karaniwang output stream).
Ibinabalik ang bilang ng mga naka-print na argumento.

o int printf(string format, ...)
Ipinapakita ang lahat ng (pinaghihiwalay ng kuwit) na argumento sa screen (ibig sabihin, ang karaniwang output stream).
Ibinabalik ang bilang ng mga naka-print na argumento (ang format string ay binibilang bilang isang argumento).

If format naglalaman ng mga placeholder %1 .. %n ang output ay naka-format (tingnan din
strformat).

o int putenv(string envvar)
Nagdadagdag envvar sa kasalukuyang (icmake) environment Gamitin ang format na: "VAR=value".
Ibinabalik ang 0.

o pisi baguhin ang laki (string str, int bagong haba) Nagbabalik ng kopya ng string STR, binago sa
bagong haba mga karakter. Kung bagong haba ay negatibo pagkatapos ay ibinalik ang isang walang laman na string,
if bagong haba Lumagpas ang ni str haba pagkatapos ay ang mga bagong idinagdag na mga character ay sinisimulan
sa mga blangkong espasyo.

o int sizeof(listahan l)
Hindi na ginagamit: gamitin nakinig.

o int sizeoflist(listahan l)
Hindi na ginagamit: gamitin nakinig.

o listahan stat (string entry)
Kita stat(2) impormasyon ng entry sa direktoryo pagpasok bilang isang listahan. Ang ibinalik na listahan
ay may dalawang elemento: ang elemento 0 ay ang katangian halaga, ang elemento 1 ay naglalaman ng laki ng
ang file

Ibinabalik ang mga katangian bilang mga bit-flag, na binubuo mula sa sumusunod na paunang natukoy
constants:

S_IFCHR S_IFDIR S_IFREG
S_IREAD S_IWRITE S_IEXEC

Tingnan ang stat(2) manu-manong pahina para sa mga kahulugan ng mga constant na ito.

o listahan stat (pagsusuri, pisi entry)
Pareho sa nakaraang function, ngunit sa pamamagitan ng pagtukoy pagsuri as P_NOCHECK ang function na
ay hindi wawakasan ang script. Bagkus, bumabalik ito stat(2) ang ibinalik na halaga.

o int strchr(string str, pisi mga karakter)
Ibinabalik ang unang index sa STR kung saan ang alinman sa mga karakter ay nasa tank ay natagpuan, o -1
if STR ay hindi naglalaman ng alinman sa mga character sa tank.

o int strlen(string str)
Ibinabalik ang bilang ng mga character sa STR (hindi binibilang ang huling 0).

o int strfind(string haystack, pisi karayom)
Ibinabalik ang index sa haystack saan karayom ay matatagpuan, o -1 kung karayom ay hindi nakapaloob
in haystack.
ito tungkulin ay tinatawag strstr() in mga bersyon bago 7.00.

o int strformat(string format,...)
Nagbabalik ng na-format na string gamit ang mga placeholder %1 .. %2 upang tugunan ang mga argumento
sumusunod na format.
Halimbawa:

walang bisa pangunahing ()
{
int i = 10;
int j = 20;
string s1;
string s2;
// tradisyonal na diskarte:
s1 = (string)i + " " + (string)j + " " + (string)i;
// gamit ang strformat:
s2 = strformat("%1 %2 %1", i, j);
printf("s1 = %1, s2 = %2\n", s1, s2);
}

o pisi strlwr(string s)
Nagbabalik ng lower-case na duplicate ng s.

o listahan strtok(string str, pisi mga separator)
Nagbabalik ng listahan na naglalaman ng lahat ng mga substring ng STR pinaghihiwalay ng isa o higit pa
(magkakasunod) na mga character sa mga separator. Hal, strtok("hello icmake's+world", " +")
ibinabalik ang listahan na naglalaman ng tatlong mga string "Kamusta", "ni icmake", at "mundo".

o pisi strupr(string s)
Nagbabalik ng upper-case na duplicate ng s.

o pisi substr(string teksto, int offset, int bilangin)
Nagbabalik ng substring ng teksto, Nagsisimula sa ginalaw, na binubuo ng mga bilangin mga karakter. Kung
ginalaw lumampas (o katumbas) ng laki ng string o kung bilangin <= 0, pagkatapos ay isang walang laman na string
ay ibinalik. Kung ginalaw ay mas mababa sa 0 pagkatapos ay 0 ang ginagamit.

o int sistema (string utos)
Mga Execute utos. Isinasaad ng return value ang exit value ng executed command. Ang
pisi utos maaaring maglaman ng pag-redirect at/o mga piping na character.

o int sistema (int pagsuri, pisi utos)
Parehong pag-andar tulad ng nakaraang pag-andar, ngunit sa pamamagitan ng pagtukoy pagsuri as
NOT_CHECKED hindi wawakasan ng function ang script. Sa halip, ibabalik nito ang
tinatawag na exit status ng command, o 0x7f00 kung ang utos ay hindi natagpuan.

o pisi gupitin (string s)
Nagbabalik ng kopya ng s nang walang nangunguna at sumusunod na mga puting espasyo.

o pisi trimleft(string str)
Nagbabalik ng kopya ng s nang walang nangungunang mga puting espasyo.

o pisi gupitin (string s)
Nagbabalik ng kopya ng s nang walang trailing white space.

USER TINUTUKOY Mga function

walang bisa pangunahin

Icmake ang mga script ay dapat ibigay sa isang function na tinukoy ng gumagamit pangunahin. Ang pagpapaandar pangunahin ay
tatlong opsyonal na parameter, na maaaring tanggalin sa huli (envp) sa nauna
(argc), tulad sa C. Ang buong prototype nito ay (tandaan: walang bisa uri ng pagbabalik):

void main(int argc, list argv, list envp)

In main (),

o argc kumakatawan sa bilang ng mga elemento sa argv;

o argv naglalaman ng mga argumento, na ang elemento 0 ay katumbas ng pangalan ng .bim
maghain;

o envp naglalaman ng mga variable na `kapaligiran'. Ang function nakinig ay maaaring magamit upang
matukoy ang bilang ng mga elemento nito. Mga elemento sa envp magkaroon ng form
variable=halaga. Bilang kahalili, ang function getenv maaaring gamitin sa pagkuha ng a
tiyak na variable ng kapaligiran kaagad. Halimbawa:

void main(int argc, list argv)
{
listahan sa Compile;
int idx;

kung (argc == 1)
paggamit(elemento(0, argv));

kung (toCompile = binago("*.cc"))
{
para sa (idx = haba(toCompile); idx--; )
compile(elemento(idx, toCompile));

if (getenv("dryrun")[0] == "0")
pag-uugnay(elemento(2, argv));
}
}

Ang pagkakaroon ng pagsisimula sa lahat ng mga global na variable sa pagkakasunud-sunod ng kanilang mga kahulugan pangunahin ay tinatawag ng
icmakeang run-time na sistema ng suporta upang magsagawa ng mga karagdagang gawain.

Bilang karagdagan tinukoy gumagamit function

Maaaring tukuyin ang mga karagdagang function. Kapag natukoy na, ang mga function na ito ay maaaring tawagin. Pasulong
Ang pagtukoy sa alinman sa mga variable o function ay hindi suportado, ngunit pabalik-balik na pagtawag
mga function ay. Dahil ang mga deklarasyon ng function ay hindi suportado ang hindi direktang recursion ay hindi
suportado alinman.

Ang mga function na tinukoy ng user ay dapat may mga sumusunod na elemento:

o Ang uri ng pagbabalik ng function, na dapat isa sa walang bisa, int, pisi or listahan. Doon
ay walang default na uri.

o Pangalan ng function, hal, sumulat ng libro.

o Isang listahan ng parameter, na tumutukoy sa zero o higit pang mga parameter na pinaghihiwalay ng kuwit. Ang mga parameter
ang kanilang mga sarili ay binubuo ng isang uri ng pangalan (int, pisi, O listahan) na sinusundan ng
identifier ng parameter. Hal, (string outfile, pisi pinagmulan).

o A katawan napapaligiran ng isang pares ng kulot na braces ({ at }).

Maaaring maglaman ang mga function body (opsyonal na nasimulan) ng mga variable na kahulugan. Variable
nagsisimula ang mga kahulugan sa isang pangalan ng uri, na sinusundan ng isa o higit pang kuwit na pinaghihiwalay (opsyonal
nasimulan) variable na mga identifier. Kung ang isang variable ay hindi tahasang nasimulan ito ay
sinimulan bilang default. Bilang default an int ang variable ay pinasimulan sa 0, a pisi is
sinimulan sa isang walang laman na string ("") at isang listahan ay pinasimulan sa isang listahan ng mga zero na elemento.

Bilang karagdagan sa mga variable na kahulugan, ang mga katawan ay maaaring maglaman ng zero o higit pang mga pahayag (cf.
seksyon Daloy Kontrol). Tandaan na ang mga variable ay maaaring tukuyin (at opsyonal na masimulan)
kahit saan sa loob ng mga function, at gayundin sa kung, para at habang mga pahayag.

Ang pag-uugali ng icmake-mga script na gumagamit ng mga non-void function na hindi nagbabalik ng mga value ay hindi
tinukoy.

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