bc (programozási nyelv)

A bc egy lebegőpontos kalkulátor nyelv, 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 sorrendjében dolgozza fel. Miután minden fájlt feldolgozott a bc a standard 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 standard 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.

Használata

A parancs általános alakja: bc [ -lws ] [ fájl ... ]

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 tizedespont után levőkét. Például:

• A .000001 számnak a hossza és a léptéke is 6.
• 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 tizedes 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.

Ezeknek a változóknak lehet értéket adni, de kifejezésben is használhatóak.

Kifejezések és utasítások

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 egyszá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 legális 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[fIexpr]

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))).) Megjegyzendő, 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 asszociatív *, / é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(fIparametersfB) 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 standard 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 bemenetrő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 standard 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.

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éleké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 standard 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 tízes 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).

Példa

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); }

Források

• GNU bc kézikönyv
• POSIX bc kézikönyv
• Plan 9 bc kézikönyv Archiválva 2015. február 5-i dátummal a Wayback Machine-ben
• 7th Edition Unix bc manual page Archiválva 2006. október 8-i dátummal a Wayback Machine-ben
• comp.compilers cikk a C-BC-ről

Külső hivatkozások

• 6th Edition Unix bc source code, a bc első kiadása 1975 májusából