• Kezdő oldal
• Bevezetés
  • Kis összefoglaló
  • A történet
  • Felhasználói felület
  • Környezeti paraméterek
  • Környezet
• Nyelvi elemek
  • Azonosítók
  • Megjegyzések
• Típusok, típuskonstrukciók
  • Típusok
  • Pszeudo függvények és konstansok
  • Változók
  • Operátorok és beépített függvények
• Utasítások, vezérlési szerkezetek
  • Utasítás szerekezet
  • Hatókör
  • Értékadás, üres utasítás
  • Szekvencia
  • Elágazás
  • Ciklus
  • I/O utasítások
  • Lemezkezelő utasítások
• Alprogramok, modulok
• Absztrakt adattípusok
• Sablonok
• Kivételkezelés
  • Hibakezelés
• Objektum-orientált programozás
• Helyesség
• Párhuzamosság
• Szabványos könyvtárak
• Fordítók
• További információk
  • Könyvek magyar, angol nyelven
  • linkek
• Példaprogramok
• Készítők

Az DBase nyelv család

Típusok, típuskonstrukciók

Típusok

dBase:

Clipper:

A kiterjesztett tömbkezelés jellemzõi a következõk:

A Clipper további új adattípusai:

FoxPro:

Vannak olyan beépített típusok, amik adattáblákban és memóriában is tárolhatók:

Ezenkívül vannak típusok, amik csak adattáblákban fordulhatnak elõ:

Pszeudofüggvények és konstansok

dBase:

Clipper:

Felhasználó által definiált parancs- vagy fordítási direktíva specifikálása.

A#command és a #translate között a különbség annyi, hogy a #command direktíva az illesztést csak teljes utasítás esetén végzi el, míg a #translate részutasítások esetében is.

A #command és a #translate hatóköre megegyezik a #define hatókörével: a definíció csak az aktuális program (.prg) állományban érvényes a megadás helyétõl az állomány végéig, kivéve, ha a definiálás az STD.CH-ban történt, vagy ha a fordítási parancshoz a /U paramétert is megadtuk. A #define-nal ellentétben, sem a #command sem a #translate definíciót nem lehet explicit módon definiálatlanul hagyni, és az #undef direktíva sincs hatással rájuk.

Konstanshozzárendelés vagy pszeudo-függvény definiálása.

Megjegyzés: a#define különbséget tesz a kis- és nagybetûk között, ellentétben a #command és a #translate azonosítóival.

• Ellenõrzõ azonosító definiálása az #ifdef, illetve #ifndefdirektívákhoz.
  Ebben az esetben nem adunk meg helyettesítõ szöveget, hanem az azonosítót egy késõbbi #ifdef vagy #ifndef direktívával ellenõrizzük.
• Egy azonosítóhoz konstans értéket rendelünk.
  Elõnyei: a fordítóprogram jóval gyorsabban mûködik a konstansok alkalmazása esetén, mint változóknál; a változók memóriaterületet foglalnak, míg a konstansok nem (memória-megtakarítás).
• Fordítási pszeudo-függvény definiálása.
  A pszeudo-függvények kiértékelése és behelyettesítése a fordítás idején történik meg.
  Példa: #define AREA(hossz, szel) (hossz * szel) A pszeudo-függvények a felhasználó által definiált függvényeknél jóval gyorsabb végrehajtást és kisebb memóriaterület foglalását eredményezik, hátránya ugyanakkor, hogy nehezebb a debuggerrel történõ nyomkövetésük, behatárolt hatókörrel rendelkezek és nem hagyhatók el argumentumok.
  Pszeudo-függvény definiálására a #command és a #translate célszerûbb./li>

Fordítási hiba generálása és üzenet megjelenítése.

Programrész fordítása definiált azonosító esetén.

Programrész fordítása nem definiált azonosító esetén.

Az aktuális állomány kiegészítése egy másik állománnyal.

• az aktuális könyvtárban,
• a /I paraméterrel megadott könyvtárakban,
• az INCLUDE környezeti változóval definiált könyvtárakban.

A #define makródefiniálás megszüntetése.

FoxPro:

Az alábbi direktívák a Clipperhez hasonlóan használhatók:

Változók

Általánosan:

Változók bárhol deklarálhatók a programban, egyszerűen azzal, hogy értéket adunk neki.
Egy változónak nincs fix típusa, ezért mindig olyan típusú, amilyen értéket utoljára kapott, tehát egy változó típusa változhat a program futása közben.

dBase:

1. Nyitott adatbázis összes mezője (kivéve a memo típusúakat) Meződefiníció részei:

   Mezőnév:

   • legfeljebb 10 karakter hosszú
   • betűvel kezdődik
   • betűt, számjegyet és '_'-t tartalmazhat
   • nincs más konvenció, így foglalt szavak sincsenek!

   Mezőtípus: (a definiáláskor egyetlen betű)

   • C = karakteres
   • N = numerikus
   • D = datum
   • L = logikai
   • M = "memo"

   Mezőszélesség:

   Mezőben tárolni kívánt karakterek vagy számjegyek száma.
   Numerikus esetben a tizedespont és a tizedesjegyek is beleszámítandók, és külön meg kell adni, hogy ebből hány karaktert is szánunk a tizedesjegyeknek.
   A többi típus esetén a méret kötött, nem változtatható, így magadása sem kötelező.
2. Memóriaváltozók:
   Ha egy vátozó neve megegyezik egy, az aktuális adatbázis-állomány egy mezőjének nevével, akkor e név beírása mindig a mezőre vonatkozik!
   pl.: datum nevű változó és megyegyező nevű mező eseténesetén:
   • datum: a mezőre hivatkozik
   • m-> datum: a változóra hivatkozik.
   Egyszerre legfeljebb 256 memóriaváltozó lehet, és ezek összes tárigénye nem haladhatja meg a 6000 byte-ot!
   Memóriaváltozók láthatósága:
   1. Lokális deklaráció:
      PRIVATE < mem. vált.-lista> a program lefutása után autómatikusan megszűnnek
   2. Globális deklaráció: PUBLIC < mem. vált.-lista > a program befejezése után is lekérdezhetőek!!
   Memória változó megszüntetése:
   • RELEASE
   • CLEAR MEMORY
   Finomság: PRIVATE ALL [LIKE |EXCEPT] < mem. vált nv >
   A parancs hatására a megfelelő nevű váltázók mind lokálisan jönnek létre. Ezáltal lokális tulajdonságúvá tehetünk egy felsőbb szinten már lérehozott változót is ;)

Clipper:

A nyelv sok standard szót definiál, ezek használhatók változónevekként is.
A változónevek nem kis-nagybetû érzékenyek.
Változót "deklarálhatok" a következõ utasításokkal:

• LOCAL: érvényességük arra az eljárásra, függvényre terjed ki, amelyben deklarálva lettek. Ha ez a függvény vagy eljárás többször is meghívásra kerül, minden alkalommal új LOCAL változók jönnek létre, még akkor is, ha rekurzív módon a függvény önmagát hívja. A LOCAL változók a deklaráció utáni elsõ hivatkozástól kezdve élnek.
• STATIC: érvényességük a deklarálás helye szerinti aktuális eljárásra vagy függvényre, illetve az ebbõl meghívott összes eljárásra és függvényre kiterjed.
  Ha a STATIC változót a fõprogramban deklaráljuk, akkor a teljes programrendszerben érvényes.
  Ha deklarálására egy alsóbb szintû eljárásban vagy függvényben került sor, akkor a felsõbb szintre történõ visszatéréssel a változó elvész, kivéve ha a fordításhoz megadjuk a /N paramétert.
  A STATIC változók deklarálásukkal azonnal létrejönnek, és ha nem adunk nekik azonnal értéket, akkor a NIL értéket veszik fel.
• PRIVATE: a futás ideje alatt dinamikusan jönnek létre a PRIVATE vagy a PARAMETERS utasítás hatására. Ha egy változót nem deklarálunk, akkor automatikusan a PRIVATE deklarációt kapja. Érvényességük a deklaráció helyétõl mindaddig terjed, amíg egy másik PRIVATE utasítással azonos nevû változót nem deklarálunk, vagy a RELEASE paranccsal nem töröljük. Kezdeti értékadás hiányában a NIL értéket veszik fel.
• PUBLIC: dinamikusan a futás ideje alatt jönnek létre. Érvényességük a deklaráció helyétõl mindaddig terjed, amíg egy másik PUBLIC utasítással azonos nevû változót nem deklarálunk, vagy egy RELEASE paranccsal nem töröljük. Ha a program valamely részén a PUBLIC változóval azonos nevû PRIVATE változót deklarálunk, akkor a PUBLIC változó érvényessége felfüggesztõdik arra az idõre, amíg a PRIVATE változó érvényben van. A deklarált, de kezdeti értékkel el nem látott PUBLIC változók alapértelmezése a hamis (.F.) érték.

FoxPro:

Használhatók a Clipper lehetõségei, valamint bevezettek egy új deklarációt:
REGIONAL: Olyan változót deklarál melynek élettartama az adott régió, tehát a régió végén megszûnik. (A régió egy eljárás egy része.)

Operátorok

dBase:

Karakteres típusokra:

'+' 

'-' 

'$' 

AT ( Kkif1 , Kkif2 ) 

LOWER ( Kkif )

UPPER ( Kkif ) 

LEFT ( Kkif , Nkif ) 

RIGHT ( KKif1 , NKif ) 

SPACE ( N ) 

LTRIM ( Kkif ) 

RTRIM ( Kkif ) 

STUFF ( Kkif2 , poz , hossz , KKif2 ) 

SUBSTR ( Kkif , poz , [ hossz ] ) 

TRANSFORM( kif , maszk )

REPLICATE( Kkif , N )

Numerikus típus:

'=' 

'<' 

'>' 

'<=' 

'>=' 

'#' vagy '<>' 

'-' 

'+' 

'**' vagy '^' 

'*' 

'/' 

'()'

ABS (N ) 

EXP ( N ) 

INT ( N ) 

LOG ( N ) 

MAX ( N1 , N2 ) 

MIN ( N1 , N2 ) 

MOD ( N1 ,N2 ) 

ROUND ( Nkif ,n ) 

SQRT ( N ) 

Dátum típus:

Minden, a numerikus típusnál felsorolt összehasonlító muvelet és az értékadás használható.

DATE() 

CDOW ( < Dkif > ) 

CMONTH ( < Dkif > ) 

DAY () 

DOW ( < Dkif > ) 

MONTH ( < Dkif > ) 

TIME () 

YEAR ( < Dkif > ) 

Logikai típus:

'.NOT.' 

'.AND.' 

'.OR.' 

'.XOR.' 

Clipper:

A fentieken kívül a Clipperben a következõ új és kibõvített funkciójú operátorok jelentek meg:

• Egy új in-line operátor ( : = ), amely lehetõvé tesz a deklaráló utasításokban történõ azonnali értékadást. Ez a fajta értékadás az összes változóosztály számára - beleértve a mezõváltozókat is - alkalmazható.
• Egy új növelõ operátor ( ++ ), amelyet a numerikus értékek növelésére lehet használni.
• Egy új csökkentõ operátor ( -- ), amelyet a numerikus értékek csökkentésére lehet használni.
• A makró operátor ( & ) kibõvített formában alkalmazható, amelyek most már komplex karakteres kifejezés is értelmezhetõ. A kifejezést zárójelek közé kell tenni, például: &( elsokif + masodkif )
• Egy új továbbító operátor, amellyel üzenetek küldhetõk a felhasználói interface objektumaihoz.
• További új értékadó operátorok: +=, -=, *=, /=, %= és **= vagy ^=, melyeknek jelentése a C-beliekkel azonos.

Karakteres típus:

A fix hosszúságú értékek tárolására a karakteres változókat alkalmazzuk.
A változók egyes karakterei a CHR(32)-CHR(126), valamint CHR(128)-CHR(255), illetve a CHR(0) értékeket tartalmazhatják.

A karakteres változók értékét aposztrófok, idézõjelek vagy szögletes zárójelek között kell megadni.
A karakteres változó nulla értéke a két határolójel egymás utáni megadása jelenti.

= :

= = :

!= , <> vagy #:

< :

<= :

> :

>= :

= vagy STORE :

:=  :

+= :

-= :

$ :

REPLACE:

ALLTRIM:

ASC:

CTOD:

EMPTY:

LEN:

PADC:

PADL:

PADR:

SPACE:

VAL:

Numerikus típus:

Numerikus típusúnak azokat az adatokat definiáljuk, melyekkel matematikai mûveleteket kívánunk végezni.

A Clipper a numerikus adattípusban a számjegyeket, a tizedes pontot, valamint a plusz és a mínusz elõjelet engedi meg.
A Clipper a numerikus értékeket az IEEE szabvány szerinti duplapontosságú lebegõpontos formátumban tárolja a megengedett 10^(-308) és 10^(308) közötti tartományban. A pontosság 16 értékes tizedesjegy, a numerikus értékek képernyõn történõ megjelenítése 32 jegyig lehetséges.
A 32-nél több jegybõl álló számok megjelenítése explicit módon történik: a 16 értékes tizedesjegy és a 10 megfelelõ hatványkitevõjének megadásával.

Fontos: A karakteres változókkal ellentétben a numerikus típusú változókat nem kell határolójelek közé tenni. Ha mégis így teszünk, akkor karakteres típusként veszi figyelembe.

% :

++ :

-- :

= vagy = = :

!= :

STORE :

:= :

+= :

-= :

*= :

/= :

**= vagy ^= :

%= :

REPLACE :

CHR :

EMPTY :

STR :

Dátum típus:

A dátum típusú változókkal egy naptári dátum azonosítható. Az alapértelmezés az amerikai dátumforma: hh/nn/[cc]ee. A dátumbeli elválasztójelek a SET DATE paranccsal állíthatók be, illetve változtathatók. A Clipper minden helyes dátumot elfogad 0100.01.01. és 2999.12.31. között, illetve értelmezi az üres dátumkifejezést is. A rendezés kronologikus a dátumformától függetlenül. A dátumtípusú változókkal történõ számolásokhoz a dátumkifejezést numerikus formára kell konvertálni a CTOD() függvénnyel. A zárójelen belüli dátumot idézõjelek, aposztrófok vagy szögletes zárójelek közé kell tenni.

EMPTY():

DAY():

MONTH():

YEAR():

DOW():

CDOW():

CMONTH():

Logikai típus:

Logikai típusú az az adat, amely a Boole-algebra szerinti értéket hordoz, ami lehet: igaz, hamis; igen, nem vagy on, off.
Ezeknek megfelelõen az értékek valamelyike lehet: igaz - y, Y, t, T; vagy hamis - n, N, f, F.

Rendezéskor a hamis érték mindig kisebb mint az igaz érték.

= vagy = =:

!=, <> vagy # :

Memo típus:

A memo változók lényegében változó hosszúságú karakteres adatok.

A memo mezõk az adatbázishoz kapcsolódnak, abból 10 karaktert foglalnak el. Ezt pointerként használják az aktuális adat eléréséhez, amely egy .dbt állományban helyezkedik el.
Mivel a memo mezõk lényegében karakteres mezõk, így rájuk a karakteres mezõkre vonatkozó elõírások érvényesek, például hosszuk 65535 karakter lehet, két memo mezõ összehasonlítása is a karakteres típusnál ismertetett módon megy végbe, illetve alkalmazható az összes karakteres mûvelet.

Mivel memo típusú csak mezõ lehet, ezért karaktersorozatos megfelelõje nincs.
Ugyanakkor karaktersorozat, mint érték megadható egy REPLACE paranccsal a memo mezõ számára.

HARDCR :

MEMOEDIT :

MEMOLINE :

MEMOREAD :

MEMOTRAN :

MEMOWRIT :

MLCOUNT :

MLPOS :

NIL adattípus:

A NIL az 5.0 verzióban bevezetett új típus.

Szükségességét az indokolta, hogy a nem deklarált adatok ne vezessenek hibajelzéshez.

Tetszõleges adattípus esetén alkalmazható, formája: NIL. Változó deklarálásakor automatikusan megkapja ezt az értéket.

= vagy == :

!= , <> vagy # :

< :

<= :

> :

>= :

= vagy STORE :

:= :

EMPTY:

A kódblokk:

A Clipper 5.0 egy teljesen új - adattípusok közé sorolható - eleme.

Lényegében a futtatható program egy részének áthelyezése egy másik helyre.
Felfogható úgy is, mint egy név nélküli függvényértékadás, mivel a Clipper a kódblokkot értékként kezeli.

A kódblokkok nagyon hasonlóak a makrókhoz, de lényeges különbség van köztük. A makrók olyan karaktersorozatok, melyek futás ideje alatt jönnek létre, míg a kódblokkok a fordítás ideje alatt.

A kódblokkok jóval rugalmasabbak, és hatékonyabbak, hiszen például makróval nem lehet static vagy local változó értékét illetve paraméterértéket továbbítani.
Definiálása:
{ | [ < argumentumlista > ] | < kifejezéslista > }
ahol az argumentumlista használata és szabályai megegyeznek a függvények és eljárások argumentumlistájánál írtakka,
a kifejezéseknek helyes Clipper kifejezéseknek kell lenniük, és nem tartalmazhatnak deklarációs vagy ciklus utasításokat.

A kódblokkot közrezáró függõleges vonalból mindig egy párnak kell lennie, ellenkezõ esetben a Clipper a kapcsos zárójelek között megadottakat tömbnek adott értékadásnak tekinti.

= :

= :

AEVAL :

DBEVAL :

EVAL :

A kódblokkok lényegében egysoros függvénynek is felfoghatók.
Használatuk az EVAL() függvénnyel lehetséges, ebben két paramétert kell megadni: az elsõ a blokk neve, a második a bemeneti érték.
A visszaadott érték a kódblokk szerinti érték.
Például:

A kódblokkok hatóköre arra a függvényre vagy eljárásra terjed ki, amelyben azt létrehozták.

A kódblokk olyan speciális adattípus, amely végrehajtható programkódot tartalmaz. Kiválóan alkalmazható olyan "fekete doboz" függvények esetében, amelyeknél nem tudjuk a visszaadott érték típusát meghatározni.

A kódblokkok nem írhatók át direkt módon adatbázisba.
Ha egy kódblokkot adatbázisba kívánunk helyezni, hogy késõbb fel tudjuk használni az értékét, akkor a következõ módon járhatunk el:

 USE Sue NEW 
/* Egy karakteres mezõ feltöltése a kódblokkot hordozó karaktersorozattal */
APPEND BLANK
REPLACE blokkmezo WITH "{|| Ertek()}"
...
// A blokk felhasználása egy késõbbi alkalommal
sajatblokk := &(blokkmezo)
EVAL(sajatblokk)

Megjegyzés: A fenti példában nem alkalmazhattuk egy lépésben az EVAL ( & ( blokkmezo ) ) formát, mivel a fordító egyszerre csak egy fordítási lépést hajt végre, ezért ez nem vezetne helyes eredményre.

A tömb:

Tömbnek nevezzük az azonos nevû változók együttesét, melynek elemeit indexeikkel érhetjük el.

Az egyes elemek tetszõleges adattípusúak lehetnek - a memo típus kivételével, amely egy különleges mezõtípusnak számít.

Az elemek egy tömbön belül eltérõ típusúak is lehetnek, elemként tartalmazhatnak másik tömböt, vagy kódblokkot is.

A tömbök egy azonosítóból és az ezt követõ szögletes zárójelek közé írt egy vagy több számból állnak.
A szögletes zárójel a tömbdefiníció része, kötelezõ megadni!

A tömbnek legalább egy dimenzióval kell rendelkeznie.

A többdimenziós tömbök kétféleképpen adhatók meg:

< azonosító > [ < elem1 > , < elem2 > , ... ]
< azonosító > [ < elem1 > ] [ < elem2 > ] ...

A dimenziók mérete dinamikusan deklarálható.

Egy tömb létrehozható az ARRAY, DBSTRUCT, DIRECTORY függvények segítségével is.

A tömbelemek címzése a tömb nevével és indexével történik, ugyanakkor mind a név, mind az index helyén állhat olyan kifejezés, amely a megfelelõ azonosítást biztosítja.

A tömbök elemei számára egyidejûleg értéket csak a deklaráláskor tudunk adni (egyidejûleg ekkor is csak NIL értéket), illetve ehhez a megfelelõ függvényeket kell alkalmazni.

A speciális tömbkezelõ függvények közül az ARRAY() a NIL értékkel, a DBSTRUCT() az adatbázis szerkezetével, a DIRECTORY() a lemezkönyvtár információival tölti fel (a létrehozással egyidejûleg) a tömbelemeket.

Az AFILL() függvény segítségével a teljes tömb, vagy annak megadott részei kaphatnak egyidejûleg értéket, például az elsõ tíz elem az 1, a második tíz elem a 2 értéket kapja:

AFILL(tomb, 1, 1, 10)
AFILL(tomb, 2, 11, 10)

A tömbök - nevükkel való hivatkozással - függvényargumentumként szerepeltethetõk, illetve azok visszaadott értékei lehetnek.

A tömbök mérete menet közben növelhetõ és csökkenthetõ az ASIZE() függvénnyel. A tömbméretének növelését eredményezi az AADD() függvény is, ezzel elem adható a tömb végéhez.

A tömbök mérete meghatározható a LEN() függvény segítségével.
Többdimenziós tömb esetén a függvény az elsõ index szerinti értéket adja vissza (ennek az a magyarázata, hogy a többdimenziós tömböket a Clipper "altömbökként" kezeli, ezért ha a következõ dimenzió méretére vagyunk kíváncsiak, akkor az elsõ elemre hivatkozással kérdezzük le a hosszt).

Két tömb összehasonlítása az == operátorral lehetséges.
Ugyanakkor ezzel a módszerrel két tömb csak akkor bizonyul azonosnak, ha a memóriában azonos címen találhatók.
(Az = operator nem alkalmazható tömbök összehasonlítására)

Tömbelem beszúrását az ADEL illetve az AINS függvényekkel végezhetjük el.
Az elõbbi úgy törli a megadott indexû elemet, hogy minden elemet egyel balra tol, az utolsó elem pedig a NIL értéket veszi fel.
Az AINS pedig a megadott helyre beszúr egy NIL értékû elemet, az utolsó elem pedig elvész.

Az elemek az ACOPY függvénnyel másolhatók illetve az ACLONE függvénnyel duplikálhatók. Az elõbbi a tömb elemeinek értékét másolja másik tömbbe, míg az utóbbi a meglévõ tömb egészérõl készít másolatot.

ASORT(): ezzel a függvénnyel a tömb összes eleme, vagy annak meghatározott része nagyság szerint sorbarendezhetõ. ASCAN(): tömbelemek értéke szerinti keresés. (kis és nagybetûk között különbséget tesz)

FoxPro:

A Foxproban használhatók a DBase lehetõségei.

Powered by PHP and XML
Valid XHTML and CSS
Copgyright © 2010 - ELTE IK, Programozási Nyelvek és Fordítóprogramok Tanszék