Provided by: manpages-hu_20010119-5_all bug

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 környezeti változó
              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)