A „mau nyelvű függvény” fogalma alatt sok mindent értünk. Nagy vonalakban ez valamiféle olyan program vagy programrészlet, amit szeretett mau programnyel
vünkben írtunk meg, s ezt meg akarja hívni valamely másik program, hogy hasznos munkát végezzen neki. Na most, ennek azért van ám egy rakás variációja, s azoknak alesetei... Mert kezdjük azzal, hogy az se teljesen világos, mármint nincs rá elfogadott terminológia, mi is az, hogy „függvény”!
Sokan ugyanis a szubrutinokat is függvényeknek tartják. Ilyesmiket mi már tudunk gyártani a meglevő eszközeinkkel, s ezzel simán elértük a régi C-64 -es számítógép BASIC-jének színvonalát és használhatóságát. Ha ehhez hozzá
vesszük, hogy a szubrutinon belül képesek vagyunk külön névteret generálni, aminek paramétereket is átadhatunk, sőt e névterek tetszőleges mélységben egymásba is ágyazhatóak - nos, akkor meg bőven túl is haladtuk az említett nyelv színvonalát már! Általában ugyanis azért úgy vélekednek a programozók közt a legtöbben, hogy csak az függvény, ami saját névtérrel rendelkezik. Igen ám, de a névtér fogalmába ők bele szokták érteni a függvényen belüli címkéket is, amik nálunk viszont globálisak! Továbbá, igazi függvényeknek azért szokott ám neve is lenni, ami nálunk eddig még nincs. Címkéink vannak, függvényneveink még nincsenek.
Mindez még tovább bonyolódik azzal, hogy egy „függvény”, az legalább 2 nagyon különböző valami lehet: mert lehet egyrészt ugyanabban a fájlban amiben a főprogram, vagy, általánosabb megfogalmazásban, az a program ami őt a függ
vényt meg óhajtja hívni, s az is lehet - legalábbis illik hogy megoldjuk ennek lehetőségét - hogy a hívott függvény egy teljesen külön forrásprogram. Utóbbi esetre nem jó megoldás az hogy a shellen keresztül hívjuk meg, mert úgy csak stringeket adhatnánk át neki paraméterül, visszatérési értékként meg jószerivel semmit se fogadhatnánk tőle, ha csak fájlba nem menti az eredményeket. Ami azonban rém durva dolog volna. És természetesen a meghívott fügvénynek is tudnia kell hívni más függvényeket, olyanokat amik vele egy fájlban vannak, s olyanokat is amik külön fájlban vannak. Szóval az ügy cseppet se egyszerű. Akit érdekel hogy mindez hogyan lett megoldva programozástechnikailag, nézzen utána a Bevezetésben említett tanulmányomnak, itt most csak a szintaxis ismertetésére szorítkozom.
Nos, e szintaxis a következő:
Mindenekelőtt: szigorúan a főprogram, a „main” kell legyen a programfájl legisleg
elején. Őt nem muszáj elnevezni (sőt, nem is szabad...), de ettől még neki akkor is, automatikusan lesz név adva, s ez a „BIGBOSS” név lesz, ami magyarul azt jelenti: „NAGYFŐNÖK”. Ez különben fordítási paraméterként állítható, ennek cseréjéhez a vz.h fileban kell megkeresni e sort és kicserélni a nekünk tetszőre:
#define MAINPROGRAMNEVE "BIGBOSS"
Aztán, e main függvény illik hogy valahol végetérjen egy
XX
utasítással, ez adja vissza a vezérlést a shellnek, ez nálunk az „exit” parancs. S ezután jöhetnek a mindenféle, fájlon belüli függvények. Ezek alakja a következő példa szerinti:
„Hányados és maradék megjegyzésekkel” // Két számnak adja vissza a hányadosát és a maradékát
#i@e, // első paraméter - az osztandó
#i@m // második paraméter - az osztó
#i@h=(@e)/(@m); // hányados
#i@M=(@e)><(@m); // maradék
\ // Itt jön az output paraméterek átadása // Ez egy többsoros megjegyzés!
#i@h, // Első output paraméter - a hányados
#i@M; // Második output paraméter, a maradék xx
Mint látható, a függvény neve egyszerűen a magyar szabványoknak megfelelő idézőjelek közt áll, azaz alul nyitó, felül záró idézőjelek közt. Jelen esetben a függvény neve az, hogy "Hányados és maradék megjegyzésekkel". Az idézőjelek nem tartoznak a függvény nevéhez. A bal oldali, alsó nyitó idézőjel a címkéinkhez hasonlóan szigorúan csak egy sor legislegelső karaktere lehet!
Mint már a fenti példából is sejthető, a címke neve abszolút bármiféle (UTF-8 kódolás szerinti) karaktert tartalmazhat, ékezeteseket is, kivéve a 0 kódú, azaz
„szakmaian” írva a CHR$(0) bájtot, ami amúgy is stringek végét jelzi, valamint a magyar nyitó- és záró idézőjeleket tehát a „ és ” karaktereket, meg az „angol”
idézőjelet, tehát a " jelet.
Utóbbit, az angol idézőjelet tulajdonképpen tartalmazhatja elvileg a címke neve, nincsen azzal semmi baj, épp csak ezesetben rém macerás lesz a használata, mert speciális módon lehet csak megadni stringekben, szóval ettől inkább óvakodjunk. Teli van sok ezer karakterrel az UTF-8 kódolású UNICODE táblázat, vannak benne mindenféle gyönyörűséges vesszők, aposztrófok meg más határolókarakterek, minden mi szem-szájnak ingere, erről az egy jelről nyugodtan lemondhatunk. Ismétlem azonban nem kötelező erről lemondani, mindenki szivathatja magát vele ha akarja, de minek ha nem muszáj... Esetleges rossz-szándékú kritikusaimnak megjegyzem, függvényeim elnevezése még e korlátozás mellett is messze nagyobb szabadságot nyújt mint a C, C++, Pascal vagy más nyelvek elnevezési szabályai, mert ugyan melyikben is tehető ékezetes karakter is a függvény nevébe, még szóköz sem... a mau nyelvben ez mind SZABAD, még kínai, héber, koreai, japán vagy akármi más karaktereket is! Azaz, ha tegyük fel valami olyan szubrutint készítünk, ami a legendás izraeli énekesnő, Ofra Haza élettörténetéről ír ki információkat, vagy valamit az ő dalaival kapcsolatban végez, akkor az e feladatot ellátó függvénynek nyugodtan adhatjuk az ő nevét úgy, ahogy az eredetileg írva van, héber betűkkel:
„הזח הרפע” // Ofra Haza függvénye
Vagy ha esetleg hinduk számára készítünk vallásos tárgyú programot, ott esetleg hasznos lehet ha a Szaraszvatí istennővel kapcsolatos dolgokat kiirató függvény neve épp az, hogy Szaraszvatí, de természetesen dévanagári írással és karakterekkel, mert ugye India nagy részén az a legelterjedtebb, azaz ekkor így nézhet ki a függvény kezdete:
„सरससतत” // Szaraszvatí függvény
Vagy ha netán tibeti nyelvű dolgokkal kapcsolatos programot írunk, esetleg jó ötletnek tűnhet egy függvény nevének az „Om Mani Padme Hum” közismert mantra nevét adni, persze úgy, ahogy azt ott ejtik, azaz „Om Ma Ni Pe Me Hung”, s mindezt tibeti karakterekkel írva:
„ཨཨ་མ་ཎཎ་པདདད་ཧཧ” // Om Ma Ni Pe Me Hung
Mindez szerintem tök jópofa dolog. Természetesen azonban nem muszáj élni e káprázatos lehetőséggel, a múltbaragadt fosszilis ókonzervatívok megmaradhat
nak az angol ABC 26 karaktere mellett is, senki se tiltja meg nekik.
A függvény meghívása pedig a következő szintaxis szerint történik:
(„"Hányados és maradék megjegyzésekkel"” 26, 7 \ #i@H, #i@M); // Függvény meghívása, 2 input és 2 output paraméterrel
Azaz, a függvényt meghívó utasítás tulajdonképpen a kerek nyitó zárójel és az utána következő alul nyitó („magyar”...) idézőjel. Ezután nem muszáj hogy egy angol idézőjelek közt levő függvénynév álljon, mert állhat ott tetszőleges string
kifejezés is, például olyasmi, hogy
#s@f
de nyilvánvaló, hogy a legtöbbször egyszerűen ki szeretnénk írni oda a függvény nevét, s nem változókban eltárolva meghívni azt. Na most amennyiben ki akarjuk írni, akkor azt angol idézőjelek közt kell megtegyük, mert az azok közti karakterláncot alakítja át az interpreterünk stringgé. Most már gondolom érthető, miért nem jó ötlet ha a függvénynek a nevében is szerepel angol idézőjel...
A függvény nevét meghatározó stringkifejezés után egy záró magyar idézőjelnek kell állnia. Ezután hogy mi jön, attól függ, milyen a meghivandó függvény:
akarunk-e neki paramétereket átadni, s várunk-e tőle visszatérési értékeket. Ha ezek egyike se áll fenn, egyszerűen egy csukózárójel kell következzék.
Ha adunk át input paramétereket, akkor a csukóidézőjel után kell felsorolni azon aritmetikai vagy stringkifejezéseket, melyek a paraméterek. Ezek érték szerint lesznek átadva, azaz ha itt változókat adunk meg, azok tartalmát nem módosítja a meghívott függvény. A paramétereket egymástól elválaszthatja vessző, de ez nem kötelező.
Ahogy végetért az input paraméterek listája, következik egy \ jel, azaz egy
„visszaperjel”, angolul backslash. Ez az a baromság amit mindig is utáltam a Windows alatt, az, ami ott az egyes könyvtárakat elválasztja egymástól. Linux alatt szerencsére megszabadultam ettől az idiótaságtól, ott a könyvtárszeparátor a normális per-jel. Most azonban szükségem volt valami speciális jelre, amit nem nagyon használok máshol, főleg nem aritmetikai vagy string kifejezésekben műveleti jelként, s így felhasználtam e backslash jelet, mert itt még elviselhető a jelenléte, tudniillik nem lesz nagyon gyakran szükség a használatára feltehetően.
Szóval ez a jel jelzi azt, hogy nincs több átadandó input paraméter, s következnek az úgynevezett „output paraméterek”. Amennyiben azok nincsenek, akkor a backslash jelet természetesen a csukózárójel követi, sőt, azesetben magára a backslash jelre sincs szükségünk, jöhet az input paraméterek után rögvest a csukózárójel!
Na most azonban ha vannak output paraméterek, pontosabban „visszatérési értékek”, ezeket természetesen a meghívott függvény fogja szolgáltatni, ezokból a
hívási helyen a \ jel után már nem állhat aritmetikai vagy string kifejezés, hanem kizárólag csak VÁLTOZÓK, méghozzá olyan változók, amik nem a rövidített nevükön szerepelnek, hogy mondjuk @d, hanem teljes alakjukban, kitéve eléjük a casting operátor jelet is, hogy például #i@d, tudniillik másképp nem tudja majd az interpreter, a hívott függvény visszatérési értékét milyen típusú változóba helyezze el!
Természetesen az output paramétereket is elválaszthatja egymástól vessző, de ez se kötelező. Az utolsó output paramétert kell kövesse a függvényhívást lezáró kerek csukózárójel, a ).
A hívott függvény a nevének végét követő csukó azaz „felső állású” magyar idézőjel utáni első karakternél kezdődik, mármint a végrehajtása kezdődik ott. Itt állhat // jelpárossal kezdődő megjegyzés, ami megmagyarázza hogy ez miféle függvény, mit csinál, stb, sőt e komment több soron át is tarthat, persze csak úgy, ha minden megjegyzéssor a // jellel kezdődik. A /*...*/ típusú kommentek viszont itt nem alkalmazhatóak. (Legalábbis egyelőre).
Mindenesetre, a ” jel után amennyiben nem kommentek állnak, akkor a hívott függvény input paramétereinek fogadásához szükséges változók kell hogy itt szerepeljenek, természetesen ezek is teljes alakjukban, a # casting operátorral jelezve a fajtájukat. E változókat egymástól elválaszthatja vessző, de ez nem kötelező, valamint ezen változók közt is állhatnak // formájú kommentek. Sőt, érdemes tudnunk, hogy bár a hívó függvénynél az input paramétereket egymás
tól, valamint az output paramétereket egymástól csak whitespace vagy vessző választhatja el, a hívott függvény esetében akár az input, akár az output paramé
terek listájában is a paraméterek elválasztására a pontosvesszőt is használhatjuk, ha akarjuk!
Vagyis, a hívási helyen nem használhatunk kommenteket, magának a hívott függvénynek a törzsében azonban a paraméterátadási helyeken igencsak szabad kommentelési lehetőségünk van, ami nagyon jó, mert kifejezetten helyes, ha alaposan elmagyarázzuk, melyik változó mire szolgál egy függvényben.
Amint a hívott függvénynél felsoroltuk az input változókat, kezdődik a lényegi kód, a függvény törzse. Ennek kezdetét semmiféle speciális jel nem kell hogy jelölje, tudniillik azt hogy ez hol kezdődik, onnan tudja, hogy elfogytak a hívási helyen az input változók/kifejezések, azaz ha nincs már több paraméter amit átvehetne a hivott függvény, onnan tudja hogy innentől már nem folytatódik az ő paraméterlistája, TEHÁT csakis a lényegi rész következhet, a végrehajtandó kód.
Ennek végét pedig vagy egy
xx
utasítás jelzi (ügyeljünk rá hogy ezek kisbetűs ikszek!), ezesetben nem kell semmiféle visszatérési értéket visszaadnia, vagy egy \ karakter jelzi. Utóbbi esetben ezután következnek a visszatérési értékek. Mint írtuk, ezeket is elválaszt
hatja egymástól vessző, pontosvessző vagy // stílusú komment, de ez nem köte
lező. Minden visszatérési érték tetszőleges aritmetikai vagy stringkifejezés lehet.
Nem baj ha ezek alapvetően más típusúak mint amiket a hívó függvény output paraméterlistájában szereplő változók elvárnak, csak az a lényeg, hogy castolha
tóak legyenek arra a típusra. Na most amint vége az output paraméterlistának a hívott függvénynél, maga a függvény is végetér, ezokból ilyen esetben nem köte
lező az xx utasítás sem hogy jelezze a függvény végét. Ennek ellenére, célszerű
kiírni, hogy olvashatóbbá tegye a kódot. Valójában a hívott függvény akkor is végetér, ha szerepel a végén a \ jel, de utána egyetlen output paraméter sem, mert olyat nem is vár a hívó függvény vissza, vagy ha szerepel ugyan valahány output paraméter a hívott függvény listájában, de a hívó valamiért kevesebbet vár el, azaz kevesebbnek tart fenn változót a hívási helyen! Ezesetben nem történik semmi baj, nincs hibajelzés, a felesleges változókat nem adja át (sőt ki se szá
molja) a hívott függvény. Akkor van csak baj, ha a hívó több visszatérési értéket várna, mint amennyit a hívott szolgáltatni akarna... Ekkor hibajelzést kapunk.
NAGYON FONTOS TUDNUNK AZT IS ( !!!!!!!!!! ), hogy bár minden függvény végrehajtása mindig, kivétel nélkül a legelején kezdődik minden meghíváskor, ám a függvény által felhasznált belső változók értéke csak az első meghíváskor garantáltan nulla! Ugyanis az egyes meghívások során NEM TÖRLŐDIK A KORÁBBAN MEGKAPOTT ÉRTÉKÜK, akármennyi legyen is az!
Meg lehetett volna oldani könnyen, hogy ez ne így legyen, s filóztam is rajta, hogy megcsináljam-e — úgy kb egyetlen rövid programsor beszúrásából állt volna csak az egész! Mégsem tettem így, azaz ez tényleg a legkifejezettebben „nem bug hanem feature”, ahogy mondani szokás. Nagyonis sok esetben rendkívül hasznos ugyanis, ha a függvény képes emlékezni mindenfélékre az „előző életéből”! Például ha apránként adogatunk át neki mindenféle értékeket, melyeknek nem lehet előre tudni a darabszámát, ezekkel ő bütyköl mindenfélét, azt hogy nem jön több adat neki egy speciális adatféleség jelzi például nulla vagy negatív érték, s ekkor ő visszaad pár fontos adatot, mondjuk a kapott paraméterek darabszámát, átlagát, összegét, vagy lineáris regressziót számol belőlük, stb. Ha nem emlékezne az előző hívások eredményeire, akkor effélét csak rém macerás kerülőutakon lehetne leprogramozni. Ha ellenben emlékszik az előző értékekre, akkor az ilyesmi nagyon könnyű, ellenben azon esetek megvalósítása se nehéz, amikor nem szabad emlékeznie a korábbi adatokra: azon fontos változókat ugyanis, melyek nem szabad hogy korábban létrejött adatokat tartalmazzanak, egyszerűen explicit módon nullára kell állítani a program legelején, például így:
#c@c=0;
Arra az esetre ha sok adatot kéne lenullázni a függvény elején, két megoldás is megkönnyíti az életünket. Egyik az, hogy valahova ahova nekünk tetszik, beírjuk ezt a kódba:
00;
Ez garantáltan minden „single” adatot lenulláz, azaz minden nem tömb változót és nem veremváltozót, ezenfelül nullára állítja az if utasítás eredményét tároló flagot és a BRAINFUCK flagot is (utóbbiról egy későbbi fejezetben lesz elmagya
rázva, hogy mi a fene is az). Ez egy igen durva, azonban rém gyors módszer a
„tiszta lappal induláshoz”. Fontos azonban észben tartani, hogy ez a kapott input paramétereket is elfelejteti a függvénnyel, azaz ha azokra mégis szükség van, előbb verembe vagy tömbbe kell menteni őket! Ezenkívül, a lenullázás csak a numerikus változókra vonatkozik, a stringváltozókra NEM.
Abban az esetben ha mindent le szeretnénk nullázni a függvény indulásakor úgy, ahogy azt fentebb a 00; utasításnál írtam, de KIVÉVE az input adatokat, azt az input adatok listája előtt kell jelölnünk, EGYETLEN nulla jellel, eképp (zölddel emeltem ki a nulla helyét az alábbi példában):
„Hányados és maradék” 0 // Két számnak adja vissza a hányadosát és a maradékát
#i@e; // első paraméter - az osztandó
#i@m // második paraméter - az osztó // Itt kezdődik a függvénytörzs
#i@h=(@e)/(@m); // hányados
#i@M=(@e)><(@m); // maradék
\#i@h; // hányados #i@M;
xx
Ellentétben a korábban bemutatott névterekkel, ami a függvényeket illeti, azok is külön névtérrel rendelkeznek, de ezek olyan névterek, hogy a függvények esetén a CÍMKÉK IS ebben a külön névtérben vannak már, azok se globálisak a függvény számára, azaz egy fájlban minden függvénynek (és a „main” programnak is) lehet ugyanolyan nevű címkéje.
Megjegyzendő, hogy ha az interpreter morog valami hiba miatt, akkor általában igyekszik közölni a hibaüzenetében azt a konkrét, bájtra pontos pozíciót, ahol szerinte a hiba megjelenik a fájlban. Tapasztalataim szerint ha nem is mindig, de az esetek óriási többségében egész jól eltalálja a hiba helyét. Ez azonban csak akkor igazán informatív a programozónak, sajnos, ha a hiba a főprogramban van.
Függvények esetén ugyanis a hiba pozíciója a függvény kezdetétől számítódik, s nem a fájl elejétől számított pozíciót adja meg. Ezen nyilván lehetne segíteni, nem akarom e dolgot featureként feltüntetni, bár lehetne védeni ezt a hibajelzési stílust is, szóval nem tartom bugnak se. Elismerem azonban hogy jobb lenne a fájl elejétől számított pozíciót kijelezni, a dolog azonban nem olyan egyszerű mint azt némelyek gondolnák, és e kérdés alárendelt fontosságú a szememben, szóval előbb fontosabb dolgokat akarok megoldani. Csak jelzem hogy e problémáról tudok. Bár a szememben nem „probléma”, legfeljebb „szépséghiba”.
Minden beolvasott függvénynek van egy sorszáma. Egy függvény mindenképpen van, ez maga a „main”, azaz a főprogram, ezesetben ha nincs más függvény, az ő sorszáma természetesen a nulla. Amint azonban több függvény is van beolvasva, nem okvetlenül lesz igaz hogy a main sorszáma a nulla, tudniillik amint beolvasta a teljes forrásprogramot, a függvényeket névsorba rendezi, a stringeknél bemu
tatott sorrendiségi szabályok szerint. Ezesetben a „main” nagy valószínűséggel már nem a nullás számot kapja.
Na most, ez nem baj, mert az esetek óriási többségében bennünket abszolút nem érdekel, miféle sorszáma van egy függvénynek, mert úgyis név szerint hivatko
zunk rájuk! Ennek hogy mi a sorszáma, csak rendkívül speciális esetekben lehet jelentősége. Ekkor azonban fontos lehet megtudni, melyik függvénynek mi a sorszáma, vagy ellenkezőleg, melyik sorszámhoz épp melyik függvény tartozik, egyáltalán, hány függvényt is olvastunk épp be?! Nos, ezt a legkönnyebben úgy tudhatjuk meg, ha a forrásfájlba valahova beírjuk e kis függvényt, aztán amikor nekünk úgy tetszik, meghívjuk:
„Betöltve”
"Betöltve " ?l ?f; " függvény!\n"
{| ?f // A ciklus annyiszor hajtódik végre, ahány betöltött függvény van,
"Az " ?l ?f-?|; ". függvény neve: „" ?s ?#s "„”" ?f-?|; "”\n"
|}
xx
Szerintem aki eddig eljutott a könyvem olvasásában, az komolyan érdeklődik a mau programnyelv iránt, s eddig bőven felszedett magára annyi ismeretet e nyelvből, hogy a fenti kis függvényből külön szájbarágás nélkül is megértse, miféle szintaktikával tehet szert a betöltött függvények darabszámára, s hogy melyik számhoz melyik függvénynév tartozik.
Íme egy példa ennek használatára, azaz e fenti függvény összeépítve egy olyan
„main” programmal, ami kiírja a teljes programfájl kódját, azaz kilistázza önmaga forrását:
(„"Betöltve"”);
"A progi mérete: " ?l ?p; " bájt\n";
"Most kiírom önmagam programkódját:\n"
{| ?p; ? ?#c "P" ?p-?|; |}
/;
XX
„Betöltve”
"Betöltve " ?l ?f; " függvény!\n"
{| ?f // A ciklus annyiszor hajtódik végre, ahány betöltött függvény van,
"Az " ?l ?f-?|; ". függvény neve: „" ?s ?#s "„”" ?f-?|; "”\n"
|}
xx
Némileg egyszerűbben írva a fenti programot, az így néz ki:
(„"Betöltve"”);
"A progi mérete: " ?l ?p; " bájt\n";
"Most kiírom önmagam programkódját:\n"
{| ?p; ? ?#c "P" {|}; |} /;
XX
„Betöltve”
"Betöltve " ?l ?f; " függvény!\n"
{| ?f // A ciklus annyiszor hajtódik végre, ahány betöltött függvény van,
"Az " ?l {|}; ". függvény neve: „" ?s ?#s "„”" {|}; "”\n"
|}
xx
Ennek ellenkezője, amikor ismerjük a függvény nevét, s keressük a sorszámát:
"A \"Betöltve\" nevű függvény sorszáma: " ?l ?#l "[]" "Betöltve"; /;
Na most a sorszámokat azért lehet jó ismerni némelykor, mert van lehetőségünk függvényt meghívni nem a nevének, hanem a sorszámának a megadásával!
Például, ha igaz az hogy egy függvény sorszáma 1, akkor azt így is meghívhatjuk:
([1]); // Meghívtunk egy függvényt paraméterek nélkül. Nincs se input, se output paraméter
Természetesen ez csak a legegyszerűbb példa, mert egyrészt az „1” helyén a szögletes zárójelek közt tetszőleges aritmetikai kifejezés állhat ami meghatározza a meghivandó függvény sorszámát, másrészt a szögletes zárójeles kifejezés kizárólag a függvény nevét helyettesíti, azaz a csukó szögletes zárójel után halál
nyugodtan meg lehet adni ugyanúgy az input és/vagy output paraméterlistát, mintha a „"név"” szintaktikával a függvényt a maga neve szerint hívtuk volna meg. Azaz a függvényhívó szintaxis szerint, ha a függvényre igaz az, hogy a neve NÉV és a sorszáma X, akkor a függvényhívás vagy úgy kell kezdődjön hogy
(„"NÉV"”
Vagy úgy, hogy
([X]
és minden más teljesen azonos. Ja és a "NÉV" helyén állhat tetszőleges stringkifejezés, az X helyén pedig tetszőleges aritmetikai kifejezés.
És hogy e sorszám szerinti hívogatásra miért van lehetőség... Hát amiatt, mert függvényből nem csak annyi lehet mint változóból, hanem akár jócskán több is!
Konkrétan, jelenleg most maximum 10 ezer lehet betöltve egyszerre, de ennek értéke fordítási paraméterként állítható, a vz.h include fájlban van meghatározva ezzel az utasítással:
#define PGMTOMBSIZE 10000
Na de nem ez a legnagyobb baj, hanem hogy a függvényeknél már semmi esetre se követhettem el olyan illetlenséget, hogy a nevük csak maximum 1 vagy 2 vagy
Na de nem ez a legnagyobb baj, hanem hogy a függvényeknél már semmi esetre se követhettem el olyan illetlenséget, hogy a nevük csak maximum 1 vagy 2 vagy