Provided by:
manpages-hu_20010119-4_all 
NÉV
bc - Lebegőpontos kalkulátor nyelv
ÁTTEKINTÉS
bc [ -lws ] [ fjl ... ]
VERZIÓ
Ez a kézikönyv lap a GNU bc 1.03-as verzióját írja le.
LEÍRÁS
bc egy olyan nyelv, amely lebegőpontos számolást nyújt, interaktív
végrehajtással. Van némi hasonlóság a C programozási nyelvvel. Egy
standard matematikai könyvtár megadható parancssor paraméterként. Ha
szükséges, a matematikai könyvtárat definiálni kell, mielőtt bármilyen
más fájlt feldolgoznánk. A bc a megadott fájlokban levő kódot a megadás
sorrenjében dolgozza fel. Miután minden fájlt feldolgozott a bc a
szabványos bemenetről vár további utasításokat. Minden kódot a
beolvasás pillanatában végrehajt. (Ha egy fájlban olyan utasítás
található, amely megállítja a feldolgozót, a bc nem fog a szabványos
bemenetről olvasni.
A bc ezen implementációja sok bővítéssel rendelkezik a POSIX
standardhoz képest. Parancssor opcióval megadható, hogy a program
ezeknél figyelmeztessen, vagy dobja vissza őket. Ez a dokumentum az
ezen feldolgozó által elfogadott nyelvet írja le. A kiterjesztések
természetesen jelölésre kerülnek.
OPCIÓK
-l Definiálja a standard matematikai könyvtárat.
-w Figyelmeztet a POSIX bc-hez képest használt kiterjesztésekre.
-s Csak a pontos POSIX bc nyelvet dolgozza fel.
SZÁMOK
A bc legalapvetőbb eleme a szám. A számok pontossága bármekkora lehet.
Ez a pontosság mind az egész, mind a tört részre vonatkozik. Minden
szám belsőleg decimálisan tárolódik, és a számítások is decimálisan
hajtódnak végre. (Ez a verzió az osztásnál és a szorzásnál csonkít.) A
számoknak két jellemzője van, a hossz és a lépték. A hossz a
szignifikáns decimális számjegyek számát jelenti, a lépték pedig a
tizedspont után levőkét. Például:
.000001 számnak a hossza és a léptéke is 6.
míg az 1935.000 számnak a hossza 7, a léptéke 3.
VÁLTOZÓK
A számokat két fajta változóban lehet tárolni, egyszerű változóban vagy
tömbben. Mind az egyszerű, mind a tömbváltozónak van neve. A neveknek
betűvel kell kezdődniük, ezt követhetik számok, betűk vagy aláhúzások.
Minden betűnek kisbetűnek kell lennie. (A teljes alfanumerikus nevek
már egy kiterjesztés. A POSIX bc-ben minden név egy kisbetűből áll.) A
változó típusa a kontextusból tisztán kiderül, mivel minden tömb
változót egy szögletes zárójel pár ([]) követ.
Négy speciális változó van, scale, ibase, obase, és last. A scale azt
definiálja, hogy néhány művelet a tizdes pont után hány számjegyet
használjon. A scale alapértelmezett értéke 0. Az ibase és az obase
definiálja a bemeneti és a kimeneti számrendszer konverziót. Az
alapértelmezett számrendszer mind a bemenetre, mind a kimenetre 10-es.
A last (kiterjesztés) változóban az utolsó kiírt érték szerepel. Ez
később kerül részletezésre. Ezeknek vátlozóknak lehet értéket adni, de
kifejezésben is használhatóak.
MEGJEGYZÉS
A megjegyzések a bc-ben a /* karakterekkel kezdődnek és a */ karakterek
jelzik a végét. A megjegyzések bárhol megjelenhetnek, és a bemenetben
egy szóközt jelentenek. (Ez azt jelenti, hogy a megjegyzések
elhatárolnak más objektumokat. Például, egy megjegyzés nem lehet egy
változónév közepén.) A megjegyzésekben bármennyi újsor lehet (sor
vége), a megjegyzés kezdete és vége között.
KIFEJEZÉSEK
A számokat kifejezésekkel és utasításokkal lehet manipulálni. Mivel a
nyelvet interaktívra készítették, az utasítások és a kifejezések rögtön
végrehajtódnak. Nincs "fő" program (main függvény). A kód olyan
sorrendben hajtódik végre, ahogy a bc beolvassa. (A függvények, később
kerülnek leírásra, a beolvasás sorrendjében kerülnek definiálásra.)
Egy egyszerű kifejezés egy konstans. A bc a konstanst az ibase
változóban megadott bemeneti számrendszer szerint decimális számmá
konvertálja. (Kivétel a függvényeknél.) Az ibase érvényes értékei 2-től
16-ig terjednek. Ezen a határon túli értéket megadva az ibase
változónak, a változó értéke 2 vagy 16 lesz. A bemenő számok a 0-9-ig
és az A-F-ig terjedő karaktereket tartalmazhatják. (Megjegyzés:
Nagybetűknek kell lenniük. A kisbetűk a változóknak vannak fenntartva.)
Az egy számjegyű számoknak mindig a számjegy az értéke, az ibase
változótól függetlenül (pl.: A = 10). A több számjegyű számoknál a bc
az ibase-nél nagyobb számjegyeket bc - 1-re cseréli. Ezáltal, a FFF
mindig a lehetó legnagyobb háromjegyű számot jelenti.
A teljes kifejezések hasonlóak a többi magas szintű nyelvben levőkhöz.
Mivel csak egyetlen típusú szám van, nincs szabály a típusok
keverésének kezelésére. Minden kifejezésnek van egy pontossága. Ez az
eredeti számokból, az elvégzett műveletekból és még sok egyébből
tevődik össze, az értéke a scale változóban található. Ezen változó
legális értékei a 0-tól a C nyelvben egész számnak megadható legnagyobb
értékig terjednek.
Itt következik a legalis kifejezések leírása, az "expr" a teljes
kifejezésre, a "var" pedig egy egyszerű, vagy egy tömb változóra
vonatkozik. Egy egyszerű változóra a
name
míg egy tömbre a
name[expr]
leírásával hivatkozhatunk. Hacsak másként nem specifikáljuk, az
eredmény pontossága a kifejezések pontosságának a maximuma lesz.
- expr Az eredmény a kifejezés negáltja.
++ var A változó értéke eggyel nő, és az eredmény a változó új értéke
lesz.
-- var A változó értéke eggyel csökken, és az eredmény a változó új
értéke lesz.
var ++ A kifejezés eredménye a változó eredeti értéke, majd a változó
értéke nő eggyel.
var -- A kifejezés eredménye a változó eredeti értéke, majd a változó
értéke csökken eggyel.
expr + expr
Az eredmény a két kifejezés összege.
expr - expr
Az eredmény a két kifejezés különbsége.
expr * expr
Az eredmény a két kifejezés szorzata.
expr / expr
Az eredmény a két kifejezés hányadosa. Az eredmény pontosságát a
scale változó értéke határozza meg.
expr % expr
Az eredmény a "maradék", amely a következőképpen kerül
kiszámolásra. Az a%b kiszámolásához először, kiszámolásra kerül
az a/b, scale számjegyre. Az eredmény a következőképpen adódik:
a-(a/b)*b, a pontossága a scale+scale(b) és scale(a) közül a
nagyobb lesz. Ha a scale egyenlő nullával, vagy mindkét
kifejezés egész, a maradék is egész lesz.
expr ^ expr
Az eredmény az első kifejezés a másodikra emelve. A második
kifejezésnek egésznek kell lennie. (Ha a második kifejezés nem
egész, egy figyelmeztetés generálódik, és az érték egész értékre
csonkolódik.) Az eredmény pontossága scale lesz, ha a kitevő
negatív. Ha a kitevő pozitív, az eredmény pontossága az első
kifejezés pontosságának és a kitevő értékének a szorzata és - az
első kifejezés és a scale változó értéke közül a nagyobb - közül
a kisebb lesz. (Pl. scale(a^b) = min(scale(a)*b, max( scale,
scale(a))).) Megjegyezendő, hogy az expr^0 mindig 1 értékkel
tér vissza.
( expr )
Ez megváltoztatja a kifejezés kiértékelésének standard
precedenciáját.
var = expr
A változó értéke a kifejezés lesz.
var <op>= expr
Ez ekvivalens a "var = var <op> expr" kifejezéssel, azzal a
kivétellel, hogy a "var" rész csak egyszer értékelődik ki. Ez
akkor okozhat különbséget, ha a "var" egy tömb.
A relációs kifejezések speciális kifejezés fajták, amelyek mindig 0-t,
vagy 1-et adnak vissza, 0-át, ha a reláció hamis, és 1-et, ha igaz.
Ezek bármilyen legális kifejezésben megjelenhetnek. (A bc POSIX
változatában, hogy a relációs kifejezések csak if, while és for
utasításokban szerepelhetnek, illetve csak egy tesztelésük lehetséges.)
A relációs operátorok a következők:
expr1 < expr2
Az eredmény 1, ha az expr1 kisebb, mint az expr2.
expr1 <= expr2
Az eredmény 1, ha az expr1 kisebb, vagy egyenlő, mint az expr2.
expr1 > expr2
Az eredmény 1, ha az expr1 nagyobb, mint az expr2.
expr1 >= expr2
Az eredmény 1, ha az expr1 nagyobb, vagy egyenlő, mint az expr2.
expr1 == expr2
Az eredmény 1, ha az expr1 egyenlő az expr2-vel.
expr1 != expr2
Az eredmény 1, ha az expr1 nem egyenlő az expr2-vel.
A boolean műveletek is legálisak. ( A POSIX bc-ben nincsenek boolean
műveletek.) Minden boolean műveletnek az értéke 0, vagy 1 (hamis, vagy
igaz), mint a relációs műveleteknél. A boolean műveletek a következőek:
!expr Az eredmény 1, ha a kifejezés 0.
expr && expr
Az eredmény 1, ha a mindkét kifejezés nem 0.
expr || expr
Az eredmény 1, ha a bármelyik kifejezés nem 0.
A kifejezések precedenciája a következő (alacsonytól a magas felé):
|| operátor, balról asszociatív
&& operátor, balról asszociatív
! operátor, nem asszociatív
Relációs operátorok, balról asszociatív
Értékadó operátor, jobbról asszociatív
+ és - operátorok, balról associative
*, / és % operátorok, balról asszociatív
^ operátor, jobbról asszociatív
unáris - operátor, nem asszociatív
++ és -- operátorok, nem asszociatív
Ez a precedencia úgy van megválasztva, hogy a POSIX bc alá programok is
korrekten fussanak. Emiatt, a relációs és logikai operátorokat az
értékadó operátoroknál néha szokatlan eredmény is kijöhet. Lásd a
következő kifejezést:
a = 3 < 5
A legtöbb C programozó ezt úgy értelmezi, hogy a "3 < 5" (az értéke 1)
kerül az "a" változóba. A bc itt a következőt csinálja, hozzárendeli a
3-at az "a" változóhoz, majd a 3-at összehasonlítja az 5-tel. A
legjobb, hogyha értékadó operátort használsz relációs, és logikai
operátorokkal, akkor használsz zárójeleket.
Van néhány egyéb speciális kifejezés, amelyet még a bc nyújt. Ezek a
felhasználó által definiálható függvények, és a standard függvények
hívása. Ezek a következő alakban jelennek meg: name(parameters) A
függvényekhez lásd még a felhasználó által definiált függvények
fejezetet. A standard függvények a következőek:
length ( expression )
A length függvény értéke a kifejezésben megadott szám értékes
jegyeinek száma.
read ( )
A read függvény (kiterjesztés) beolvas egy számot a szabványos
bemenetről, függetlenül attól, hogy a függvény hol található.
Figyelmeztetés: ez problémát okozhat, ha mind a program, mind az
adatok a standard bementről jönnek. A legjobb, ha ezt a
függvényt csak előre megírt programoknál használjuk, amely
adatokat kér a felhasználótól, de nem engedi meg, hogy a
felhasználó program kódot is beírjon. A read függvény értéke a
szabványos bemenetről beolvasott szám értéke, az ibase változó
értékét, mint számrendszert használva a konverzió alapjául.
scale ( expression )
A scale függvény értéke a kifejezés tizedespont mögött szereplő
számjegyeinek száma.
sqrt ( expression )
Az sqrt függvény értéke a kifejezés értékének a négyzetgyökével
egyenlő. Ha a kifejezés negatív, egy futási hiba generálódik.
UTASÍTÁSOK
Az utasítások (mint a legtöbb algebrai nyelvnél) határozzák meg a
kifejezések kiértékelésének sorrendjét. A bc-ben az utasítások akkor
hajtódnak végre, amint "arra mód van". A végrehajtás akkor történik
meg, mikor az interpreter új sor karakterrel találkozik, illetve, mikor
egy, vagy több komplett utasítás felépül. Ezen azonnali végrehajtás
miatt, az újsorok nagyon fontosak a bc-ben. Valójában, mind a
pontosvessző, mind az újsor használható utasításelválasztóként. Egy
rossz helyre rakott újsor szintaktikai hibát okoz. Mivel az újsorok
utasítás elhatárolók, el lehet őket rejteni, a backslash karakter
segítségével. A "\<nl>" karaktersorozattal, ahol az <nl> az újsort
jelenti, az újsor csak egy szóközként jelenik meg a bc-ben. Egy
utasítás lista a pontosvesszővel, vagy újsorral elválasztott utasítások
sorozata. Itt következnek a bc utasításai, és az, hogy mit csinálnak:
(A szögletes zárójelbe ([]) zárt részek az utasításból elhagyhatóak.)
expression
Ez az utasítás kétféle képpen is megjelenhet. Az egyik, mikor a
kifejezés "<változó> <értékadás> ...", ez egy értékadási
utasítás. Ha a kifejezés nem értékadási utasítás, akkor
kiértékelése után kapott eredmény kiírásra kerül a szabványos
kimenetre. A szám kiírása után egy újsor is kiírásra kerül.
Például, az "a=l" egy értékadási utasítás, míg az "(a=l)" egy
kifejezés, amelyben van egy értékadás. Minden szám az obase
változóban tárolt számrendszer alapján kerül kiírásra. Az obase
változó legális értékei 2-től a BC_BASE_MAX konstansban tárolt
értékig mehetnek. (Lásd még a HATÁRÉRTÉKEK fejezetet.) A 2-estől
a 16-os számrendszerig a számok kiírása a szokásos módon
történik. 16-osnál nagyobb számrendszereknél a bc több
karakterből álló számjegyeket használ, ahol minden magasabb
számrendszerbeli számjegynek a tizes számrendszerbeli számképe
íródik ki. A több karakteres számjegyeket egymástól a program
szóközökkel választja el. Minden számjegy annyi karakterből áll,
amennyi az "obase-1" szám kiírásához kell, 10-es
számrendszerben. Mivel a számok változó pontosságúak,
előfordulhat, hogy néhány szám kiírása nem fér ki egy sorba.
Ezeket a hosszú számokat a program sorokra tördeli, a sorok
végén egy-egy "\" karakterrel. Az egy sorba kiírt karakterek
maximális száma 70. A bc interaktivitása miatt, az utolsó kiírt
számot eltárolja egy speciális változóban. Így az utoljára kiírt
szám megkapásához nem szükséges újra leírni az egész kifejezést,
hanem csak a last változó értékét kell előszedni. A last
változónak értéket is lehet adni, ez esetben a benne tárolt
utolsó érték egyszerűen felülíródik. Ez az érték addig marad meg
benne, amíg a következő szám kiírásra nem kerül, vagy más
értéket nem adnak neki. (Némelyik implementáció megengedi, hogy
a last változóra egy egyedüli ponttal ("."), amely nem része
számnak, hivatkozzunk.)
string A string a kimenetre íródik ki. A stringek idézőjellel
kezdődnek, és bármilyen karaktert tartalmazhatnak a következő
idézőjelig. Egyetlen karakter sem kerül értelmezésre, még az
újsor karakter sem. A string kiírása után nem íródik ki újsor
karakter.
print list
A print utasítás (kiterjesztés), a kiírás egy újabb módozatát
kínálja. A "list" egy string és kifejezés lista, vesszővel
elválasztva. Minden string vagy kifejezés a lista sorrendjében
íródik ki. Záró újsor nem íródik ki. A kifejezések
kiértékelődnek, és az eredményük a last változóban tárolásra
kerül. A stringek pedig egyszerűen kiírásra kerülnek, speciális
karaktereket is tartalmazhatnak. A speciális karakterek a
backslalsh karakterrel kezdődnek (\). A speciális karakterek a
következőek: "a" (figyelmeztetés, vagy bip), "b" (backspace),
"f" (lapdobás), "n" (újsor), "r" (kocsi vissza), "q" (idézőjel),
"t" (tabulátor) és "\" (backslash). Minden más, a backslash után
levő karaktert figyelmen kívül hagy a program.
{ utasítás_lista }
Ez egy összetett utasítás. Ennek segítségével lehet több
végrehajtandó utasítást egybekapcsolni.
if ( kifejezés ) then utasítás1 [else utasítás2]
Az if kiértékeli a kifejezést, és végrehajtja az utasítás1-et,
vagy az utasítás2-t, a kifejezés értékétől függően. Ha a
kifejezés eredménye nem nulla, az utasítás1 hajtódik végre. Ha
az utasítás2 létezik, és a kifejezés eredménye nulla, az
utasítás2 hajtódik végre. (Az else ág kiterjesztés.)
while ( kifejezés ) utasítás
A while utasítás mindaddig végrehajtja az utasítást, amíg a
kifejezés eredménye nem nulla. Az utasítás minden végrehajtása
előtt kiértékeli a kifejezést. A ciklus akkor fejeződik be, ha a
kifejezés eredménye nulla lesz, vagy ha végrehajtódik egy break
utasítás.
for ( [kifejezés1] ; [kifejezés2] ; [kifejezés3] ) utasítás
A for utasítás egy utasítás ismételt végrehajtását vezérli. A
kifejezés1 a ciklus előtt kiértékelődik. A kifejezés2 az
utasítás minden végrehajtása előtt kiértékelődik. Ha nem nulla,
az utasítás végrehajtódik, ha nulla, a ciklus véget ér. Az
utasítás minden végrehajtása után, a kifejezés3 kiértékelődik,
mielőtt a kifejezés2 kiszámolódna. Ha a kifejezés1 és a
kifejezés3 hiányzik, a kiértékelődésük helyén semmi nem fog
történni. Ha a kifejezés2 hiányzik, az olyan, mintha a
kifejezés2 helyén egy olyan kifejezés lenne, amelynek az
eredménye mindig 1. (Az opcionális kifejezések egy
kiterjesztés.) A következő ekvivalens kódokat ad a for
utasításra:
kifejezés1;
while (kifejezés2) {
utasítás;
kifejezés3;
}
break Ezzel az utasítással ki lehet lépni a legbelső while, vagy for
utasításból.
continue
Ez az utasítás (kiterjesztés) azt eredményezi, hogy a legbelső
for utasítás egy új ciklust kezd.
halt Ez az utasítás (kiterjesztés), ha végrehajtódik, azt
eredményezi, hogy a bc kilép.
return Nulla értékkel tér vissza egy függvényből (lásd még a függvények
fejezetet).
return ( expression )
A kifejezés eredményével tér vissza a függvényből (lásd még a
függvények fejezetet).
PSZEUDO UTASÍTÁSOK
Ezek az utasítások a tradicionális értelemben nem utasítások. Nem
hajtódnak végre. Funkciójukat "fordítási" időben fejtik ki.
limits Kiírja a bc adott verziója által használt határokat.
Kiterjesztés.
quit Ha a quit utasítást beolvassa, a bc feldolgozó kilép. Nem
számít, hogy az utasítás hol található (pl. az "if (0 == 1)
quit" hatására is kilép a bc.)
warranty
Kiírja a figyelmeztető üzenetet. Kiterjesztés.
FÜGGVÉNYEK
A függvényekkel definiálhatunk számításokat, amelyeket csak később
kívánunk végrehajtani. A függvények a bc -ben mindig egy értéket
számolnak, és azt visszaadják a hívónak. A függvény definíciója
"dinamikus" abban az értelemben, hogy mindaddig definiálatlan, amíg a
feldolgozó nem találkozik vele a bemeneten. Ez a definícó mindaddig
használható, amíg egy ugyanezen névű függvény definicóval nem
találkozik. Az új definíció felülírja a régit. Egy függvény
definíciója a következőképpen néz ki:
define name ( parameters ) { newline
auto_list statement_list }
A függvényhívás is egy kifejezés, a következő formában:
"name(parameters)".
A paraméterek számok, vagy tömbök lehetnek (kiterjesztés). A függvény
definícójában nulla, vagy több paraméter definiálható, vesszővel
elválasztva. A számok csak érték szerinti átadással, a tömbök csak cím
szerinti átadással hívódnak meg. A tömböket a paraméterek között a
"nv[]" módon kell specifikálni. A függvényhívásnál a szám paraméterek
teljes kifejezések lehetnek. A tömböknél ugyanaz a jelölés használandó,
mint a definiáláskor. A nevesitett tömbök cím szerinti átadással
kerülnek a függvényhez. Mivel a függvény definíciója dinamikus, a
paraméterek száma és típusa csak a hívás pillanatában kerül
ellenőrzésre. Ha ebben eltérés mutatkozik, egy futási-hiba váltódik ki.
Futási-hiba váltódik ki akkor is, ha egy nem létező függvényt hívunk
meg.
Az auto_list egy opcionális változó lista, amely "helyi" változókat
tartalmazza. A szintaxisa: "auto nv, ... ;". (A pontosvessző
opcionális.) Minden nv egy auto változó neve. Tömbök is definiálhatóak
így, a szokásos módon. Ezek a változók a vermen kapnak helyet, a
függvény belépése után. A változók ezután inicializálásra kerülnek
nulla kezdőértékkel, és a függvény végrehajtása során használhatóak.
Amikor a függvény kilép, ezeket a változókat eltávolítja a veremből,
így az eredeti értékük helyreállítódik. A paraméterek is auto változók,
amelyek a függvény meghívásakor kapják meg értéküket. Az auto változók
különböznek a tradícionális helyi változóktól a következő dologban: ha
A meghívja a B függvényt, B látja az A auto változóit, hacsak B-ben
nincs ugyanezen néven is auto változó definiálva. Azon tény miatt, hogy
az auto változók és a paraméterek egy vermen kapnak helyet, a bc kezeli
a rekurzív függvényeket is.
A függvény törzse bc utasítások listája. Az utasításokat pontosvesszők,
vagy újsorok választják el. A return utasítás hatására a függvény
végrehajtása véget ér, és visszatér egy értékkel. Az első forma, a
"return", 0-át ad vissza a hívónak, míg a második, "return ( kifejezs
)", kiértékeli a kifejezést, és az eredményt adja vissza. A függvény
végén, ha mást nem írunk ki, mindig van egy "return (0)", ez megkímél
attól, hogy explicite ki kelljen írni a return utasítást.
A függvényeknél megváltozik az ibase változó használata is. A függvény
törzsében szereplő minden konstans, a függvény hívásakor használatos
ibase alapján konvertálódik. Ha az ibase-t megváltoztatjuk egy
függvényben, annak nem lesz hatása, kivéve a read standard függvényt,
amely mindig az ibase aktuális értékét használja a számok
konvertálásához.
MATEMATIKAI KÖNYVTÁR
Ha a bc-t a -l opcióval indítjuk, a matematikai könyvtár betöltődik, és
a pontosság 20-as lesz. A matematikai függvények azzal a pontossággal
számolják ki az eredményt, amely a meghívásukkor be volt állítva. A
matematikai könyvtár a következő függvényeket definiálja:
s (x) Az x (radián) színusza.
c (x) Az x (radián) koszínusza.
a (x) Az x arkusz tangense.
l (x) Az x természetes logaritmusa.
e (x) Az e x-edik hatványa.
j (n,x)
Az n-ed rendű Bessel fuggvenye x-nek.
PÉLDÁK
A /bin/sh-ban a következő utasítás visszaadja a "pi" értékét a pi
környezeti változóban.
pi=$(echo "scale=10; 4*a(1)" | bc -l)
Az itt következő példában a matematikai könyvtárban található hatvány
függvény definícióját mutatjuk be. A függvény POSIX bc nyelven íródott.
scale = 20
/* Kihasználja a következó tényt: e^x = (e^(x/2))^2.
Mikor az x elég kicsi, a következő sort használjuk:
e^x = 1 + x + x^2/2! + x^3/3! + ...
*/
define e(x) {
auto a, d, e, f, i, m, v, z
/* Ellenőrzi az x előjelét. */
if (x<0) {
m = 1
x = -x
}
/* Elófeltétel. */
z = scale;
scale = 4 + z + .44*x;
while (x > 1) {
f += 1;
x /= 2;
}
/* Inicializálja a változókat. */
v = 1+x
a = x
d = 1
for (i=2; 1; i++) {
e = (a *= x) / (d *= i)
if (e == 0) {
if (f>0) while (f--) v = v*v;
scale = z
if (m) return (1/v);
return (v/1);
}
v += e
}
}
A következő kód a bc kiterjesztett szolgáltatásait használja, egy
egyszerű csekkfüzet egyenleg kiszámolására. Legjobb, ha ezt a programot
fájlba lementjük, hogy többször is használhassuk anélkül, hogy újra be
kelljen gépelni.
scale=2
print "\nCsekkfüzet program!\n"
print " Emlékeztető, a letétek negatív tranzakciók.\n"
print " Kilépés 0 összegű tranzakció bevitelével.\n\n"
print "Kezdeti egyenleg? "; bal = read()
bal /= 1
print "\n"
while (1) {
"jelenlegi egyenleg = "; bal
"tranzakció? "; trans = read()
if (trans == 0) break;
bal -= trans
bal /= 1
}
quit
A következő függvény a faktoriális rekurzív definíciója.
define f (x) {
if (x <= 1) return (1);
return (f(x-1) * x);
}
ELTÉRÉSEK
A bc ezen verziója a POSIX P1003.2/D11 tervezete alapján készült és a
tervezethez és a tradícionális implementációhoz képest sok bővítést és
különbséget tartalmaz. Ez nincs implementálva a tradícionális
dc(1)-ben. Ez a verzió egy egyszerű feldolgozó, amely csak átfordítja
a programot. Egy "nem dokumentált" kapcsoló (-c) kiírja az átfordított
programot a szabványos kimenetre, és nem futtatja le. Ez főleg az
értelmező nyomkövetésekor és a matematikai könyvtár előkészítésekor
használatos.
A különbségek legfőbb forrásai a kiterjesztések, hol egy szolgáltatás
lett kiterjesztve, hogy több lehetősége legyen, hol pedig új
szolgáltatás lett létrehozva. A következó lista megmutatja a
különbségeket és a kiterjesztéseket.
LANG Ez a verzió nem követi a POSIX szabványt a LANG környezeti
változó használatában, és minden környezeti változó az "LC_"
prefixszel kezdődik.
nevek A tradícionális és a POSIX bc -ben a funkciók, változók és
tömbök nevei csak egy karakter hosszúak lehettek. Itt már több
karaktert is használhatunk, de a neveknek betűvel kell kezdődni
és csak betűket számokat és aláhúzásjeleket tartalmazhatnak.
Stringek
A stringek nem tartalmazhatnak NUL (ASCII nulla) karaktert. A
POSIX szerint bármilyen karakter lehet egy stringben.
last A POSIX bc-ben nincs last változó. Néhány implementáció a pontot
(.) használja erre a célra.
összehasonlítások
A POSIX bc csak az if, vagy a while utasításban enged meg
összehasonlításokat, vagy a for utasítás második kifejezésében.
Továbbá, utasításonként csak egy relációs operátor van
megengedve.
if utasítás, else ág
A POSIX bc-ben nincs else ág.
for utasítás
A POSIX bc-ben minden kifejezésnek szerepelnie kell.
&&, ||, !
A POSIX bc-ben nincsenek logikai operátorok.
read függvény
A POSIX bc-ben nincs read függvény.
print utasítás
A POSIX bc-ben nincs print utasítás.
continue utasítás
A POSIX bc-ben nincs continue utasítás.
tömb paraméterek
A POSIX bc-ben nincsenek tömb paraméterek. Más implementációkban
lehetnek.
=+, =-, =*, =/, =%, =^
A POSIX bc-ben nincs szükség ezekre a "régi stílusú" értékadó
operátorokra. Ez a verzió megengedi ezeket. Használd a limits
utasítást, hogy megtudd, hogy az installált verzió megengedi-e
ezeket. Ha igen, az "a =- 1" kifejezés csökkenti az a értékét
1-gyel, egyébként pedig az a értékét beállítja -1-re.
szóközök a számokban
A bc más implementációi megengedik szóközök használatát a
számokban. Például, az "x=1 3" kifejezés az x változóhoz
hozzárendeli a 13-at. Ebben a bc-ben ugyanez az utasítás
szintaktikai hibát ad.
hibák és végrehajtás
Ez az impelmentáció különbözik a többitől abban, hogy mely
kódokat hajtja végre, mikor egy szintaktikai, vagy más hibába
belefut. Ha egy szintaktikai hibát talál a függvény
definíciójában, a hibakezelő megpróbálja megtalálni az utasítás
elejét, és folytatni a függvény feldolgozását. Ha a szintaktikai
hiba a függvény törzsében következik be, a függvény nem lesz
definiálva, és nem lehet meghívni sem. Az interaktív
végrehajtási blokkokban levő szintaktikai hibák érvénytelenítik
az egész blokkot. Egy végrehajtási blokknak minősül az az
utasítássor, amely a következő soremelésig tart. Például:
a = 1
b = 2
ez két végrehajtási blokk és
{ a = 1
b = 2 }
ez egy. A futási-hibák hatására a jelenlegi blokk végrehajtása
befejeződik. A futási-figyelmezetetés nem állítja meg a blokk
végrehajtását.
Megszakítások
Egy interaktív végrehajtás során, a SIGINT szignál (általában a
terminálról érkező Control-C karakter generálja) hatására a
jelenlegi blokk végrehajtása megszakad. Kijelzésre kerül egy
"futási" hiba, hogy melyik függvény lett megszakítva. Miután
minden futási struktúra kiürül, egy üzenet kerül kiírásra a
felhasználó felé, hogy a bc kész további adatok fogadására.
Minden korábban definiált függvény továbbra is definiálva marad,
és minden nem-auto változóban a megszakításkori érték lesz.
Minden auto változó (a függvények paraméterei is) törlésre kerül
a kiürítési eljárás során. Nem-interaktív végrehajtáskor a
SIGINT szignál az egész bc futását megszakítja.
HATÁROK
A következő határok vannak beépítve ebbe a bc -be. Néhányuk egy
installálással megváltoztatható. Az aktuális értékeik megszerzéséhez
használd a limits utasítást.
BC_BASE_MAX
A legnagyobb kimeneti számrendszer, jelenleg 999. A maximum
bemeneti számrendszer 16.
BC_DIM_MAX
Ez a jelenlegi pontossági határ, 655535. Az ön installációjában
más lehet.
BC_SCALE_MAX
A tizedes pont előtti és utáni számjegyek számát az INT_MAX
határozza meg.
BC_STRING_MAX
A karakterek maximális száma egy stringben INT_MAX.
exponens
A hatványozás operátor (^) kitevőjének maximum értékét a
LONG_MAX határozza meg.
szorzás
A szorzó rutin inkorrekt eredményt adhat, ha a számnak (LONG_MAX
/ 90)-nél több számjegye van. 32-bites long-nál ez 23,860,929
számjegy.
kód méret
Minden függvénynek és a "fő" programnak is limitálva van a
mérete 16384 byte lefordított kódban. Ez a határ (BC_MAX_SEGS)
könnyen túlléphető, ha több, mint 16 1024 byte-os szegmensünk
van.
változó nevek
A jelenlegi limit az egyedi nevekre 32767 mind az egyszerű
változókra, mind a tömbökre és a függvényekre.
FÁJLOK
A legtöbb installációban a bc-nek nincs szüksége egyéb fájlokra. Míg a
végrehajtható program hossza fontos, illetve a C fordító nem tudja
kezelni a nagyon hosszú stringeket, a bc a standard matematikai
könyvtárat a /usr/local/lib/libmath.b fájlból olvassa be. (A fájl helye
rendszerenként változhat, lehet /lib/libmath.b is.)
DIAGNOSZTIKA
Ha egy a parancssorban szereplő fájl nem nyitható meg, a bc üzen, hogy
a fájl nem elérhető, és kilép. Ugyanígy, a fordítási és a futási idejű
diagnosztika is önmagyarázó.
HIBÁK
A hibakezelés még nem túl jó.
SZERZŐ
Philip A. Nelson
phil@cs.wwu.edu
KÖSZÖNETNYILVÁNÍTÁSOK
A szerző szeretné megköszönni Setve Sommars-nak
(Steve.Sommars@att.com), hogy oly nagy mértékben segített az
implementáció tesztelésében. Sok nagyon jó tanácsot adott.
Segítségével egy sokkal jobb terméket sikerült létrehozni.
MAGYAR FORDÍTÁS
Csehi András <acsehi@flexum.hu>
. bc(1)