Pir Zöhre Ana Forum - Pascal

Pascal Programının Genel Yapısı

Fri, 05 Dec 2008 14:10:55 +0200

Pascalın en önemli özelliklerinde birisi de yapısal bir programlama dili olmasıdır. Bu programınızı yazarken size maksimum esneklik sağlar. Aynı zamanda yazdığınız program parçalarını problemsiz bir şekilde birleştirmenizi de sağlar.

Her pascal programının ana kodu mutlaka bir BEGIN deyimi ile başlar ve END. deyimi ile biter. (End den sonra nokta olduğuna dikkatinizi çekerim. Pascal derleyicisi için bu tüm programın bittiği yer anlamına gelir.) Eğer program içerisinde aynı blok içerisinde işlem görmesini istediğiniz kodlarınız varsa bunları bir BEGIN - END bloğu içerisine alırsınız. Fakat bu sefer END’den sonra noktalı virgül ( kullanmalısınız.

Bir Pascal programının genel yapısı aşağıdaki gibidir.

Program (* Program başlığı. Buraya yazacaklarınızın programa bir etlisi olmaz *)
Uses (* Kullanılacak harici kütüphaneleri belirler*)
Type (* Tip tanımalamalarının yapıldığı blok *)
…
Const (* Sabit tanımları ve ilk değer atamaları *)
…
Var (* değişken tanımlamalarının yapıldığı blok *)
…
Procedure (* Procedure ve functionlar ana programdan önce yazılırlar. *)
Function (* Onların içinde de yerel değişken ve tip tanımalamaları için *)

Const (* tıpkı ana programda olduğu gibi bloklar kullanılır.*)
…
Var
…
Type
…

begin
…
end; { procedure veya function}

begin {ana program }
komutlar;

…

end.

If...Then...Else

Fri, 05 Dec 2008 14:09:03 +0200

Eğer…ise…değilse (If..then..else) Karar yapısı : Program yazarken en çok yapılan işlerin başında elinizdeki verilere bakarak bir karar vermek ve programın akışını bu karara göre yönlendirmek gelir. İyi programda gerekli yerlerde doğru ve etkili karar yapıları oluşturmak çok önemlidir. Çünkü bir programda en yavaş işleyen komutlardan birisi karşılaştırma komutlarıdır. Pascalda en çok kullanılan karşılaştırma ve kontrol komutu If..then..else dir.

If deyiminden sonra yapılacak karşılaştırmanın sonucu doğru(True) ise then deyiminden sonraki blok işler. Eğer karşılaştırmanın sonucu yanlış(False) ise bu sefer de else deyiminden sonraki blok işler.Else deyimi seçimlik bir deyimdir. Yani isterseniz, ya da gerekmezse bu kısmı kullanmayabilirsiniz. Bu durumda eğer karşılaştırma sonucu yanlış ise program bir sonraki komutla akışına devam eder.

[COLOR=#c5003f] Eğer else kullanacaksanız else den önceki satırda noktalı virgül kullanmamalısınız.

...
If then
begin
...
komutlar
...
end;
[ else
begin
...
komutlar
...
end;]
...

[COLOR=#c5003f] Karşılaştırma için kullanabileceğiniz operatörler için buraya tıklayın.

ÖRNEK:
Girilen bir sayının pozitif veya negatif olduğunu söyleyen program.

Var
Sayi : integer;
begin
write(‘Bir sayı girin : ‘
readln(Sayi);
if Sayi < 0 then
writeln(‘Sayi negatiftir’
else
writeln(‘Sayi Poszitiftir’
end.

Eğer isterseniz iç içe if kullanmaya devam edebilirsiniz. Bu oldukça karmaşık bir yapı oluşturabilir ancak bazı durumlarda böylesi uygulamalar zaruri olur.

Örneğin, yazdığımız bir programda eğer girilmiş olan sayı 0’dan büyükse ve 128’den küçükse I değişkenine 1 eklesin, 128..256 arasında ise I’ya 10 eklesin, 256’dan büyükse I’ya 100 eklesin. Aynı zamanda eğer bu sayı 0’dan küçükse ve –127’den büyükse 1 eksiltsin, -127..-255 arasındaysa 10 eksiltsin ve –255’den de küçükse 100 I’dan 100 eksiltsin. Bir okuyuşta anlaması bile zor olan böyle bir işlem için karşılaştırma işlemlerini ayrı ayrı yapmak veya iç içe if kullanmak durumunda kalırız ve tabii sonuç genellikle yanlış çıkar. Fakat biraz dikkat ve biraz da pratik yapmakla bu işi halletmek mümkündür. Şimdi size 2 çalışır program örnegi vereceğim. İkisi de doğru çalışıyor fakat birisi daha profesyonelce hazırlanmış. Örnekleri incelerseniz karşılaştırma komutlarından ilki olan if..then..else deyimi ile hiçbir probleminiz kalmaz.

Const
I : integer = 500;
Var
Sayi : integer;
Begin
Write('Bir sayı girin : ');
Readln(Sayi);
If (sayi > 0) and (sayi < 128) then
I := I+1;
If (sayi >= 128) and (sayi < 256) then
I := I+10;
If (sayi >= 256) then
I := I+100;
If (sayi < 0) and (sayi > -127) then
I := I-1;
If (sayi <= -127) and (sayi > -255) then
I := I-10;
If (sayi =< -255) then
I := I-100;
Writeln('İşlem sonucu I da kalan= ',I);
End. Const
I : integer = 500;
Var
Sayi : integer;
Begin
Write(‘Bir sayı girin : ‘
Readln(Sayi);
If sayı > 0 then
If sayı > 128 then
If sayı > 256 then
I := I + 100
Else
I := I +10
Else
I:= I+1
Else
If sayi < -127 then
If sayi < -256 then
I := I – 100
Else
I := I – 10
Else
I := I – 1;
Writeln(‘İşlem sonucu I da kalan=‘ , I);
End.

Case...Of

Fri, 05 Dec 2008 14:07:52 +0200

if..then..else genellikle az sayıda olan karşılaştırmalarda kullanılır. Ama eğer yapılan karşılaştırma çok karmaşıksa o zaman bu deyimi kullanmak oldukça zor olur ve çok fazla miktarda mantık hataları bulunur. Bunu engellemek için blok if deyimi diyebileceğimiz Case yapısını kullanırız.

Case yapısında karşılaştırmanın yapılacağı değişkenin alabileceği değerler göre çeşitli işlemleri toplu olarak yapabiliriz. Bir önceki konuda gösterdiğimiz örneği ele alalım. Bir if deyimi için oldukça karmaşık olan bu örnekği bir de case ile çözelim. Tabii öncelikle Case’in genel yazılışını veriyoruz.

case degişken of
durum-1 : işlem(ler);
...
durum-n : işlem(ler);
end;

Veya

case değişken of
durum-1 : işlem(ler);
...
durum-n : işlem(ler);
else
işlem(ler)
end;

Durum dediğimiz yerlerde bir yada daha fazla, virgülle ayrılmış, sabitler veya aralıklar olabilir. Mesela :

case Ch of
'A'..'Z', 'a'..'z' : WriteLn('Harf');
'0'..'9' : WriteLn('Rakam');
'+', '-', '*', '/' : WriteLn('Operator');
else
WriteLn('Özel karakter');

Else kısmı ise tamamen seçimliktir. İstemezseniz kullanmayabilirsiniz. Şimdi gelelim örneğimize… Eğer daha bakmadıysanız önceki konuyu (if-then-else)okumanızı tavsiye ederim. Yine de soruyu tekrar soruyorum. Bu sorunun hiçbir amacı olmadığını sadece bir örnek olduğunu belirtmek isterim. Boşboşuna "Buna bu nedir?..Ne işe yarar?..Ben kimim?.. Niye burdayım?" gibi felsefi konulara girmeyin. Siz örneği anlayın yeter.

Yazdığımız bir programda girilmiş olan sayı eğer 0’dan büyükse ve 128’den küçükse I değişkenine 1 eklesin, 128..256 arasında ise I’ya 10 eklesin, 256’dan büyükse I’ya 100 eklesin. Aynı zamanda eğer bu sayı 0’dan küçükse ve –127’den büyükse 1 eksiltsin, -127..-255 arasındaysa 10 eksiltsin ve –255’den de küçükse I’dan 100 eksiltsin.

Const
I : integer = 500;
Var
Sayi : integer;
Begin
Write(‘Bir sayı girin : ‘
Readln(Sayi);
If (sayi > 0) and (sayi < 128) then
I := I+1;
If (sayi >= 128) and (sayi < 256) then
I := I+10;
If (sayi >= 256) then
I := I+100;
If (sayi < 0) and (sayi > -127) then
I := I-1;
If (sayi <= -127) and (sayi > -255) then
I := I-10;
If (sayi =< -255) then
I := I-100;
Writeln(‘İşlem sonucu I da kalan=‘ , I);
End.
Const
I : integer = 500;
Var
Sayi : integer;
Begin
Write('Bir sayi girin : ');
readln(Sayi);
case Sayi of
0..128: I:= I + 1;
128..256: I := I + 10 ;
256..32767 : I := I + 100;
-127..0 : I := I - 1;
-255..-128 : I := I - 10;
-32768..-256 : I := I - 100;
end;
writeln('Islem sonunda I değeri =',I);
end.

For...Do Dongusu

Fri, 05 Dec 2008 14:06:23 +0200

Bilgisayarların en güzel yanlarından birisi de hiç sıkılmadan, şikayet etmeden aynı şeyleri yapabilmeleridir. Böylesine tekrar tekrar çalışması gereken işlemleri, bir programlama dilinde ancak döngüler vasıtası ile sağlayabiliriz. Aşağıda bu döngülerin çeşitlerini ve Pascalda nasıl kullanıldıklarını görebilirsiniz.

FOR...TO DÖNGÜSÜ

En basit döngü çeşididir. Kendisinden sonra gelen deyim veya deyimler gurubunu verilen sayı kadar çalıştırmaya yarar. Öncelikle yapısını görelim :
for değişken := ilk_değer to son_değer do komut;

veya

for değişken := ilk_değer to son_değer do
begin
komut(lar)
end;

FOR..DOWNTO DÖNGÜSÜ

for değişken := ilk_değer downto son_değer do komut;

Veya

for değişken := ilk_değer downto son_değer do
begin
komut(lar)
end;

Şimdi bu yapıya bakarak sizlere çalışma mantığını anlatmaya çalışalım. For deyiminden sonra sayaç olarak kullanılacak bir tamsayı değişken kullanılır. Döngü işlemi bu değişkenin ilk değerinden başlar ve son değere kadar 1’er 1’er artar (to) veya azalır(downto). Bazı başka dillerdekinin aksine ne artış miktarını ayarlayabilirsiniz ne de ondalıklı sayıları kullanabilirsiniz. Döngü kendisinden sonra gelen ilk deyimi veya begin..end bloğunu işletir. Döngü içinde iken döngü değişkenine müdahale etmek mümkün olmakla birlikte bunu yapmak sakıncalı olabilir. Bu yüzden döngü değişkenleri genellikle döngü içerisinde işleme tabi tutulmaz.

Bu kadar teorik bilgiden sonra şimdi bir örnek ile konumuzu pekiştirelim.

Örnek:

var
i: integer;
ismin : string;
begin
write('Ismini gir sahip :');
readln(ismin);
for i := 1 to 15 do
writeln('Merhaba ',ismin,' sahip');
end.

Repeat..Until döngüsü

Fri, 05 Dec 2008 14:05:44 +0200

Repeat deyimi ile until deyimi arasında kalan işlemleri untildeki koşul yanlış olduğu sürece tekrarlar. Untildeki koşul(lar) doğru olduğu anda döngüden çıkar.

Repeat
...
işlemler;
...
Until koşul(lar);

Örnek :

Var
I : Integer;
begin
repeat
Write('Bir sayı giriniz : ');
ReadLn(I);
until (I >= 0) and (I <= 9);
writeln(‘Sayı 0..9 arasındadir.’
End.

[COLOR=#c5003fNe olursa olsun şarta bakana kadar döngüyü bir kez çalıştırır.

[COLOR=#c5003f] Until'de belirtilen şart doğru olduğu sürece çalışır.

While-Do Döngüsü

Fri, 05 Dec 2008 14:04:38 +0200

Whiledan sonraki koşul doğru olduğu sürece işlem(ler) tekrarlanır. Whiledaki koşul(lar) doğru olduğu anda döngüden çıkar.

While koşul(lar) do
Begin
...
işlemler;
...
End;

Örnek :

Var
I : Integer;
begin
I := 100;
while((I >= 0) and (I <= 9)) do
begin
Write('Bir sayı giriniz : ');
ReadLn(I);
end;
writeln(‘Sayı 0..9 arasındadir.’
End.

[COLOR=#c5003f]Repeat-Until Döngüsünden farklı olarak öncelikle koşual bakılır sonra döngü başlar.

[COLOR=#c5003f] 1-Döngüden çıkabilmek için mutlaka koşulun döngü içinde değişmesi gerektiğine dikkat edin.

[COLOR=#c5003f]2-Birden fazla koşul kullanacaksanız bu koşulların tümünü bir parantez içine alın.

Pascalda Type Bloğunun Kullanımı

Fri, 05 Dec 2008 14:04:03 +0200

Data tipleri programcının compiler’e datanın nasıl saklanacağını bildirmekte kullandıkları bir yoldur. Bir değişken tanımlandığı anda onun data tipinide mutlaka tanımlamak zorundasınızdır.

Bazı data tipleri kullanılan dil tarafından standart olarak tanımlanmıştır zaten.Diğer tipleri
ise kullanıcı kendisi tanımlayabilir.Pascal bu tip bir esnekliği ilk sağlayan dillerden birisidir.
Kullanıcı tarafından tanımlanan tipler Pascalda TYPE bloğunda tanımlanır.

Type
tip1 = tip_tanımı1; (* Her yeni tipe bir isim verilir ve önceden tanımlı tipler kullanılarak tanımlanır *)
tip2 = tip_tanımı2; (* İstediğimiz kadar tip tanımı yapabiliriz *)
tip3 = tip1; { Yeni tanımladığımız bir tipi başka bir tip tanımı için de kullanabiliriz. Tip tanımları bazen çok karmaşık olabilecekleri gibi bazen de çok basit olabilirler }
int = integer;
CharData = array['A'..'Z'] of Byte;

Var
var1 : tip3 (* her yeni değişken için bir isim ve bir tip verilir. *)
var2, var3 : tip2 (* aynı tipte olan değişkenler bir defada tanımlanabilir *)
Sayı : int;
Char_dizi : CharData;

Type bloğunun en önemli kullanım yerleri ise record (kayıt) ve set (küme) tipi tanımlardır.

Record yapısı:
Record tipi dosyalama işlemlerinde kayıt desenini oluşturmakta kullanılır.Yani bir tek kayıt için,
o kaydın hangi alanına hangi değişkenlerle erişilebileceğinin tanımlanmasında kullanılır.Örneğin
öğrenci takibi programı yapılacaksa, bunun için aynı kayıtta hem adı, hem soyadı hem de öğrenci
no’su tutulacak olsun.Bu kayıtları tek tek değişkenlere atayıp sonra dosyaya tek tek yazdırmak
yerine, hepsini record yapısı içindeki değişkenlere atayıp bir defada dosyaya yazdırmak daha
kolaydır.Buna benzer şekilde record yapısında tanımlı bir değişkenin içine dosyadan bir kayıt
okuduğunuzda istediğiniz alanlara kolaylıkla erişirsiniz.

Örnek :

Type
Ogr_Kayit = record
No : integer;
Ad : String[30];
Soyad : String[30];
end;

var
Ogrenci : Ogr_Kayit; { Ögrenci değişkeni içinde No, Ad ve Soyad alanları }
... { bulunur. Bu alanlarla ilgili işlemler sadece öğrenci }
… { değişkeni kullanılarak yapılabilir. }

Record yapısında tanımlanmış bir değişkenin içindeki değişkenlere direkt olarak erişemezsiniz.
Bu değişkenlere erişmek için Ogrenci.Ad, Ogrenci.No,… formatını kullanmalısınız.

Var_bloğunda_tanımlanan_değişken.alanın_adı

alıntıdır.

Pascalda Dizi Kullanımı

Fri, 05 Dec 2008 14:02:50 +0200

Hangi programlama dilini kullanıyor olursanız olun değişken tanımlamanın mantığı aynıdır. Saklanacak bilginin tipine göre bir tip seçilir buna bir isim verilir ve hafızada bu değişken için bellek ayrılır. Her değişken için durum aynıdır. Pascalda bu işlemi Var bloğunda yapıyoruz. Peki aynı özelliklere sahip birden fazla değişkene ihtiyaç duyarsak ne olacak. Mesela bir öğretmen düşünün. Değişik sayılarda öğrencisi olan sınıflara girsin ve bu öğrencilerin notlarını bilgisayarda tutmaya çalışsın. Eğer dizi değişkenleri kullanmayı bilmiyorsa en kalabalık sınıfındaki öğrenci sayısı kadar değişken tanımlayacak sonra da her öğrencinin notunu kendi değişkenine ayrı ayrı atamak zorunda kalacaktır. Oysa bunu halletmenin daha kolay bir yolu var. Dizileri kullanmak. Dizilerin en önemli özelliği aynı tipteki ve birbiri ile alakalı verileri toplu olarak tanımlamaya yaramasıdır. Bu durumda örneğimizdeki öğretmen en kalabalık sınıfındaki öğrenci sayısı kadar elemanı olan bir tek dizi değişkeni tanımlar ve bilgileri bir döngü içerisinde indis kullanarak dizinin uygun yerine yerleştirir. Bu iki durumu her zamanki gibi bir tablo içinde gösterelim.

Dizi kullanmayan öğretmen
Var
OgrenciNotu1 := integer;
OgrenciNotu2 := integer;
OgrenciNotu3 := integer;
OgrenciNotu4 := integer;
...
...
OgrenciNotu30 := integer;
Begin
Write(‘1.Ogrencinin notu = ‘
Readln(OgrenciNotu1);
Write(‘2.Ogrencinin notu = ‘
Readln(OgrenciNotu2);
Write(‘3.Ogrencinin notu = ‘
Readln(OgrenciNotu3);
...
...
write(’30.Ogrencinin notu = ‘
readln(OgrenciNotu30);
end.
Dizi kullanan öğretmen
Var
OgrenciNotu : array[1..30] of integer;
I : integer;
Begin
for I := 1 to 30 do
begin
write(I,'.Ogrencinin notu = ');
readln(OgrenciNotu[i]);
end;
End.

Artık dizi kullanmanın avantajlarını biliyoruz. Bize aynı türden ve birbiri ile ilişkili bilgilere kolay erişmemizi sağlıyor. İsterseniz artık bir dizi tanımının nasıl yapıldığına bakabiliriz. Dizileri VAR bloğunda tanımlayabileceğimiz gibi, Type bloğunda da tanımlayabiliriz. Eğer TYPE bloğunu kullanırsak tanımlamış olduğumuz yeni tipi direkt değişken tipi olarak kullanabiliriz.,

değişken_ismi : array [boyut_büyüklüğü] of dizi_tipi

Boyut büyüklüğü herhangi bir standart veri tipinde olabilir. Eğer çok boyutlu bir dizi ise bunlar birbirinden virgüllerle ayrılır. Dizi tipinde ise istediğimiz herhangi bir tipi kullanabilirz. Yani hem standart tipleri hem TYPE bloğunda tanımladığımız kendi tiplerimizi kullanabiliriz. Dizinin elemanlarına köşeli parantez içerisinde verilen indis numarası ile erişiriz. Eğer dizilerimiz çok boyutlu olacaksa

Örnek tanımlamalar :

Type
arr_type = array[1..25] of real;
Str20 = String[20];

Var
IntList : array[1..100] of integer; {İnteger tipinde bir boyutlu dizi}
CharData : array['A'..'Z'] of Byte; {Char tipinde bir boyutlu dizi}
Matris : array[0..9, 0..9] of real; {real tipinde 2 boyutlu dizi}
MyStrArr : array[1..10] of Str20; {Yukarıda tanımladığım Str20 tipinde 10 elemanlı dizi}
KupData : array[1..20,1..20,1..20] of Word {Word tipinde 3 boyutlu dizi}

alıntıdır

BMP Dosyalarının Pascal İle Gösterilmesi

Fri, 05 Dec 2008 14:01:45 +0200

Programınızda BMP dosya kullanmayı düşünüyorsanız çok faydalı bir döküman. BMP dosyalarının, Pascal ile gösterilmesi dört kısımda yapılabilir :
1. Dosyanın açılması ve başlığın okunması
2. Renk tablosunun okunması ve Set edilmesi.
3. Resim verilerinin okunup grafik ekrana yollanması.
4. Dosyanın kapatılması.

Giriş: Herhangi bir hata olduğunda hata kodunun saklanacağı değer BMPError olarak adlandırılmıştır. Hata mesaj numaraları isimlendirilirken ismin önüne "bm" eklenmiştir.

Const {Hata mesaj numaraları}
bmHataYok = 0;
bmDosyaAcma = 1;
bmDosyaOkuma = 2;
bmDosyaOS2 = 3;
bmLongGenislik = 4;
bmLongYukseklik = 5;
bm16Renk = 6;
bmMilyonRenk = 7;
bmCompressFile = 8;
bmRenkPaleti = 9;
bmGrafik = 10;
bmDosyaSonu = 11;
bmNotBMP = 12;

Const {Hata mesajları}
bmMesaj : Array[0..12] of String[60] =(
'bmp dosyası başarıyla okundu.',
'bmp dosyası yerinde yok...',
'bmp dosyası okunamıyor...',
'bmp dosyası OS2 formatında kaydedilmiş...',
'Resmin genişliği 1024"then büyük ',
'Resmin yüksekliği 768"then büyük ',
'bmp dosyası 16 renk renk kullanıyor...',
'bmp dosyası 256 renkten daha çok renk kullanıyor...',
'bmp dosyası sıkıştırılarak kaydedilmiş...',
'bmp dosyasından Renk Paleti okunamıyor...',
'Bgi256 çalışmıyor...',
'Dosya Sonu!',
'Dosya bmp dosya olarak kaydedilmemiş.');

Var
BMPError : byte; {Hata kodu değişkeni}

1. Dosyanın açılması ve başlığın okunması :

BMP dosyadan farklı büyüklükteki bilgiler okunacağı için, dosya tanımlaması olarak, tipi belirtilmemiş(file) dosya tanımlaması yapılması doğru olur. Ayrıca dosyayı açarken her okumada 1 byte okuyacak şekilde ayarlanması gerekmektedir.

Var
BMPDosya : File; {BMP dosya değişkeni}

Assign(BMPDosya, DosyaIsmi); {Dosya tanımlaması}
{$I-} {Giriş - Çıkış hata sinyalini kapat}
Reset(BMPDosya, 1);{Dosyayı okuma modunda, her defasında 1 byte okuyacak şekilde aç }
If ioResult <> 0 then {Hata varsa dosya yerinde yoktur.}
begin
BMPError := bmDosyaAcma;
exit;
end;
{$I+} {Giriş - Çıkış hata sinyalini aç}

Dosya açildiktan sonra BMP header bilgilerinin alinmasi gereklidir. Onun için Type bölümünde bir Header tanimlanir ve header degiskenine esitlenir. Header söyle olamalidir.

Type {BMP header yapısı}
Theader = record
İz : array[1..2] of char; {BM}
FileSize : Longint; {Dosya uzunlığu}
Reserved : Longint; {0}
OfsetData : Longint; {Görüntü verisinin dosya içinden nereden başladığı}
InfoSize : Longint; {Başlığın bu kısımdan itibaren uzunluğu}{40 Windows bmp}
Width : Longint; {Görüntünün genişliği}
Height : Longint; {Görüntünün yüksekliği}
Planes : Word; {1 olmak zorunda}
NBits : word; {piksel başına bit sayısı}
CompType : longint; {sıkıştırma tipi}
CompSize : Longint; {Sıkıstırılmış görüntünün uzunluğu}
RowCoz : Longint; {Satır çözünürlüğü}
ColonCoz : Longint; {Sütün çözünürlüğü}
RenkCount : Longint; {kullanılan renk sayısı}
OnemliRenkCount : Longint; {Önemli renklerin sayısı}
End;

Var
Header : Theader;

Daha sonra Header dosyadan okunur. Ve gerekli kontroller yapılır.

Var
Okunan : Word; {Dosyadan Okunan byte sayısı}

{$I-} {Giriş - Çıkış hata sinyalini kapat}
BlockRead(BMPDosya, Header, SizeOf(Header), Okunan); {Başlık kısmını oku}
if (ioResult<>0) or (Okunan < SizeOf(Header)) then
begin
BMPError := bmDosyaOkuma;
exit;
end;

{$I+} {Giriş - Çıkış hata sinyalini aç}
if Header.iz <> 'BM' then {BMP mi?}
begin
BMPError := bmNotBMP;
Exit;
end;

if Header.InfoSize <> 40 then {Windows_BMP mi?}
begin
BMPError := bmDosyaOS2;
Exit;
end;

2. Renk tablosunun okunması ve Set edilmesi.

Renk tablosunun okunması için önce dosyanın kullandığı renk sayısı bulunmalıdır. Bu bilgi başlık kısmındaki Nbits değişkenine aktarılmaktadır.

var
ColorCount : word; {Kullanılan Renk sayısı}

Case Header.nBits of
4 : ColorCount := 16;
8 : ColorCount := 256;
end;

Dosyadaki renk paletinin yerleşimi farklı olduğu için iki farklı renk paleti hazırlanmalıdır. Bunlar VGA DAC için renk paleti ve BMP dosyasının renk paleti. VGA DAC için Renk paleti şöyle olmalıdır;

Type
TRgb = Record {Renk Tanımlaması}
Red, Green, Blue : byte;
end;
TRgb256 = array[0..255] of TRgb; {256 renkli grafikler için Renk Paleti}

BMP dosyası için Renk paleti ise;

Type {BMP dosyadaki renk sistemi yapısı}
TrenkDizisi = Record {Renk Tanımlaması}
Mavi, Yesil, Kirmizi : byte;
Reserved : byte;
end;
TrenkPaleti = array[0..255] of TRenkDizisi; {256 renkli grafikler için Renk Paleti}

var
RenkPaleti : TRenkPaleti;

Daha sonra renk sayısına göre dosyadan renkler okunmalıdır.

{$I-} {Giriş - Çıkış hata sinyalini kapat}
BlockRead(BMPDosya, RenkPaleti, ColorCount * 4, Okunan);
{$I+} {Giriş - Çıkış hata sinyalini aç}

Okunan renk tablosunun VGA DAC' a aktarılması gerekmektedir. Aktarırken bazı dikkat edilmesi gereken hususlar vardır. Bunlar renklerin ters sırada olduğu dikkate alınıp doğru eşleme yapılması. Fazladan bir byte fazla kaydedilmiş olması ve DAC' a yazarken değerlerin dörde bölünerek yazılması.

var
Count : byte; {Sayaç}

for count := 0 to ColorCount -1 do
begin
Rgb256[Count].Red := RenkPaleti[Count].Kirmizi shr 2;
Rgb256[Count].Green := RenkPaleti[Count].Yesil shr 2;
Rgb256[Count].Blue := RenkPaleti[Count].Mavi shr 2;
end;

Elde edilen tabloyu DAC' a aktarmak için aşağıdaki procedure' ün kullanılması işlemlere hız kazandırır.

procedure SetVGA256(var tp : TRgb256; segment, ofset, RC : word); assembler;
asm mov ax, 1012h;
mov bx, 0;
mov cx, Rc;
mov es, Segment;
mov dx, Ofset;
int 10h;
end;

Verilecek olan komut ise;
SetVga256(Rgb256, Seg(Rgb256), Ofs(Rgb256), ColorCount - 1);

3. Resim verilerinin okunup grafik ekrana yollanması:
Bmp dosyalarda her satır dördün katı olacak şekilde kaydedilmiştir. Fazlalık olan byte'lar önemsizdir. Bundan dolayı dosyadan bir satır okurken başlık kısmında verilen Width {Görüntünün genişliği} bilgisi kadar değil de Width bilgisinden büyük dörde bölünebilen ilk sayı kadar okumak gereklidir. Ya da Width kadar okuyup önemsiz byte'ları atlamak gerekmektedir. Genişliği dörde tamamlayacak bir fonksiyon aşağıda verilmiştir.

{Verilen sayıdan büyük 4'e bölünen sayıyı bulur}
function DordeTamamla(a : word) : word;
var
b : byte;

begin
b := 4 - (a mod 4);
if b <> 4 then DordeTamamla := a + b else DordeTamamla := a;
end;

Geriye kalan ters sırada kaydedilmiş olan görüntü verilerini okuyup grafik ekrana yazılmasıdır. Bu basit mantıkla da yapılabilir ancak işlemlere biraz hız kazandırmak amacıyla dosyadan bir defada okuyabileceğimiz en çok veriyi hafızaya alıp bu hafızadan grafik ekrana yazılması daha doğru olacaktır. Aşağıdaki fonksiyon bunu gerçekleştirmek için hazırlanmıştır. Fonksiyonun görevi dosyadaki sonraki bir byte'lık veriyi bulmaktır. Ancak bu işlemi yaparken dosyadan maksimum bilgiyi bir tampona atıp, buradan veriyi vermektedir. Tampon boşalınca tekrar tamponu doldurmaktadır.

const {Dosyadan Okunacak maxsimum byte sayısı}
MaxCodes = 4095;

Type {Resim datalarının saklanacağı değişken}
TData = array[1..MaxCodes] of byte;

Var
Sonraki, ToplamData : Longint;
Data : TData;

function NextCode : byte; {sonraki datayı bulur}

procedure BlokOku; {Dosyadan diziye veri okuma}
begin
{$I-} {Giriş - Çıkış hata sinyalini kapat}
BlockRead(BMPDosya, Data, sizeof(Data), Okunan); {Blok genişliği}
if (ioResult <> 0) or (Okunan = 0) then BMPError := bmDosyaSonu; {kadar oku}
{$I+}
Sonraki := 1; {sonraki datayı hazırla}
ToplamData := Okunan;
end;

begin
if ToplamData <= 0 then {toplam data sıfırsa dosyadan oku}
begin
BlokOku; {Dosyadan diziye veri oku}
if BMPError = bmDosyaSonu then exit;
end;

NextCode := Data[Sonraki]; {Sonraki datayı bul}
Dec(ToplamData);
İnc(Sonraki);
end;

Grafik ekranın açmak için Bgi256 kullanılabilir. Bunun için Bgi256.bgi dosyasının olması gerekmektedir.

procedure Bgi256(Gm : integer);
var
GraphDriver, GraphMode, ErrorCode : integer;

begin
GraphDriver := InstallUserDriver('bgi256', nil);
GraphMode := Gm;
InitGraph(GraphDriver, GraphMode, ");
ErrorCode := GraphResult;
if ErrorCode <> grOk then
begin
BMPError := bmGrafik;
Bgi := False;
Exit;
end
else
Bgi := True;
end;

16 ve 256 renkli dosyaları açmak aşağıdaki prosedürden yararlanılir.

procedure ViewBMP(Xmin, Ymin : word);
var
MaxLine : Word;
Reserved : byte;
XCount : Word;
Line : array[0..1023] of byte;
Tmp : byte;

Procedure LineView;
var
i : word;
begin
for i := 0 to Header.Width - 1 do Putpixel(Xmin + i , Ymin + MaxLine - 1, Line[i]); {Ekrana Çiz}
Xcount := 0; {Satir Sayacı = 0}
Dec(MaxLine); {Y'yi bir azalt}
if MaxLine < 0 then BMPError := bmDosyaSonu; {Y=0 ise çık}
for i := 1 to Reserved do NextCode; {Boşa olan dataları atla}
end;

begin
if BMPError <> bmHataYok then exit; {Hata varsa çık}
Reserved := DordeTamamla(Header.Width) - Header.Width;
MaxLine := Header.Height; {Görüntü yüksekliği}
Seek(BMPDosya, Header.OfsetData); {Görüntünün başına gel}
Xcount := 0; {Satir Sayacı = 0}
ToplamData := -1; {NextCode'da Blok Okuması için}
Repeat
Case ColorCount of
256 : begin
Line[XCount] := NextCode; {Datayı Satıra al}
inc(XCount); {Bir arttır}
end;
16 : begin
tmp := NextCode; {Datayı Satıra al}
Line[XCount] := tmp shr 4;
inc(XCount); {Bir arttır}
Line[XCount] := tmp and $0F;
inc(XCount); {Bir arttır}
end;
end;
if XCount >= Header.Width then LineView; {Satir sonu}
until BMPError = bmDosyaSonu; {Dosya sonuna gelince çık}
if BMPError = bmDosyaSonu then BMPError := bmHataYok; {Eğer dosya sonuysa normal}
end;

4. Dosyanın kapatılması:

if not ((BMPError = bmDosyaAcma) or (BMPError = bmDosyaOkuma)) then Close(BMPDosya); {Dosya Açılmışsa kapat}
end.

alıntıdır

Pascal Derleyicileri

Fri, 05 Dec 2008 14:00:10 +0200

Günümüzde Pascal artık neredeyse sadece kendisine gönül vermiş ve kopamamış insanların sayesinde yaşıyor. Profesyonel programcılık alanında grafik arabirimler altında görsel araçlar kullanılmaya başlandığından beri ışığı iyice söndü.
Ben bilgisayarda kendimi üretken ve hakim hissetmeye Pascal (tabi ki Borland Pascal) ile başlayanlardanım. Borlan Pascal'ın Son üç sürümünü (5.0-7.0) kullandım. O zamanlar bir 16-bit DOS derleyicisi olarak başka bir derleyiciye ihtiyaç bırakmıyordu. Bilgilendikçe derleyicinin tüm olanaklarını kullanmaya başlıyorsunuz. Biraz da Delphi, C, C++ gibi geliştirme ortamlarını tanıdıktan sonra Â«ah keşke bu özellik benim derleyicimde veya Pascal'da da olsaydıÂ» diyorsunuz. Borland artık bir Pascal derleyicisi geliştirmeyecek. Bu yüzden eksik yönleri tamalayacak başka derleyiciler aramak gerekiyor.

Eksikliği en çok hissedilenler
* 32-bit hızlı, doğal kod
* 32-bit 80386-387 dahili assembler
* Aynı adda farklı parametreli procedure tanımlama (Overload)
* Korumalı mod programlarında IDE içinden rahat hata ayıklama
* Korumalı modda harici Dos Extender gerektirmeden çalışma (dahili extender)
* ...Benimkiler bu kadar... Buradan itibaren sizin eksik bulduklarınız sıralanacak...

Bazı ticari amaçlı firmalar ve amaçları esasen ticari olmayan grupların geliştirdikleri derleyiciler mevcut. Bu derleyicilerde BP uyumluluğu aranan başlıca özelliklerdendir. Bunlardan DOS ortamı için en bilinenleri
* FPK Free Pascal
* GNU Pascal
* TMT Pascal

TMT Pascal ve Free Pascal'ın bedava komut satırı derleyicilerini kullanarak yaptığım testte TMT'nin özellikle matematiksel işlemlerde hızlı kod ürettiğini gözledim. Adına zaman zaman rastlamama rağmen GNU Pascal hakkında pek fazla bilgim yok.

Pascal Derleyicileri Listesi:
Borland/Turbo Pascal 7 (Ticari ürün)http://www.inprise.com/pascal/
Platform: MS-DOS, and Windows 3.x
Çok iyi bir IDE'ye, debugger'a, profiler'a sahip, bilinen en kaliteli Pascal geliştirme paketidir. Hakkında Internet'te dolu dolu iki ayrı bug listesi gördüm ama birçok kişi için karşılaşma olasılığı az olan buglardı. Zamanla yeni sürümleri çıkmadığı için ondaki eksiklikler alternatifleriyle kapatılmaya çalışılıyor.

Extended Pascal 32-bit for Win95/NT (Ticari ürün)http://www.prosperosoftware.com/e32iw.html
Platform: MS-DOS, and Windows.
Ciddi profesyonel program geliştiricilerin ihtiyaçlarını karşılamak için hazırlanmış, ABD ve uluslarası standartları esas alan bir Pascal çeşididir.

Free Pascal Compiler (FPC)http://www.brain.uni-freiburg.de/klaus/fpc/
Platform: DOS, Linux and OS/2.
Orjinal kodu Pascal'da yazılmış ücretsiz ve oldukça iyi bir Pascal derleyicisidir.

GNU Pascalhttp://home.pages.de/GNU-Pascal
Platform: DOS, Linux, OS/2 and 32-bit Windows.
Kaynak koduyla birlikte verilen ücretsiz bir derleyicidir. DJGPP gerektirir ve IDE içeren sürümü de vardır.

Irie Pascalhttp://www.irietools.com/download.html
Platform: Windows 95/NT, OS/2, MS-DOS and Linux.
Irie Pascal, tam 32-bit Standard (ISO/IEC 7185) Pascal kodu işler, iki programdan oluşur: Irie Pascal Compiler ve Irie Virtual Machine Interpreter.

Mystic Pascalhttp://members.tripod.com/programmerz2000/mystic.zip
Platform: MS-DOS.
Mystic Pascal shareware bir Pascal derleyicisidir.

P32http://surf.to/p32
Platform: 32-bit DOS, Win32 Console, Win32 GUI.
Vaadettiği 32-bit desteği, low level optimizasyonlar yapan derleyici, dahili assembler, IDE ve TP7 desteği ile dikkat çeken yeni bir derleyicidir. Henüz geliştirme aşamasındadır. (*Geliştirmeye katkıda bulunacak kimselere ihtiyaçları var.)

PasW32http://www.geocities.com/SiliconValley/Grid/8060/
Platform: 32-bit DOS, Win32 Console, Win32 GUI.
Delphi 2/3/4 için, Borland Pascal programlarını Delphi'de derlemeye yarayan BP uyumlu RTL.

SpeedPascalhttp://www.ndrh.de/speed/
Platform: OS/2.
OS/2 ortamı için çok iyi bir Pascal derleyicisi programı.

SURPAShttp://www.fortunecity.com/marina/tranqu...Surpas.zip
Platform: MS-DOS.
Kaynak kodunu da içeren shareware bir Pascal derleyicisidir.

Think Pascalhttp://www.benchin.com/$index.wcgi/prod/1105428
Platform: Macintosh.
Macintosh için yazılmış kendi platformunda epey popüler olan bir geliştirme ortamıdır.

TMT Pascal (Ticari ürün)http://www.tmt.com
Platform: DOS, Linux and OS/2.
32-bit derleyiciye ve IDE'ye sahip ticari bir pascal geliştirme paketidir. Son sürümü yeni, küçük ve hızlı bir extender'a sahiptir, grafik konusundaki marifetleri arttırılmış. Özellikle grafik programlama (demolar gibi) konusunda iddialı bir üründür. Tüm VESA modlarını ve LFB'ı destekler. Ücretsiz olan Lite sürümünü sitesinden indirmek ve kullanmak serbesttir. Maalesef bu bedava sürüm IDE'den yoksundur ve derlenmiş dosya boyutu kısıtlaması vardır.

Virtual Pascal v2.0 (Ticari ürün)http://www.fprint.com/products/virtual_pascal/
Platform: OS/2, Windows 95, NT and DOS.
32-bit ticari bir Pascal derleyicisi.

Win-FPC (FPC gerektirir) http://www.brain.uni-freiburg.de/klaus/fpc/download.html
Platform:Win3.x/95/98, and OS/2 Warp 4.
FPC ile Windows için program yazmaya yarayan bir IDE.

alıntıdır

Pascal İle Optimizasyon

Fri, 05 Dec 2008 13:59:22 +0200

Bu yazıda Pascal ile Intel'in x86 işlemcileri için klasik program geliştirme esas alınmış olsa da anlatılan prensipler farklı birçok geliştirme ortamı için de geçerlidir.
Giriş
1- İŞLEMCIDEN BAĞIMSIZ OPTIMIZASYONLAR
1.1- Hafıza aktarımlarını mümkün olduğunca büyük bloklar halinde yapmak doğru olur
1.2- String işlemleri için standart prosedürlerin yerine daha hızlı alternatifler bulunabilir
1.3- Genel değişkenler (global var.) ve işaretçi kullanımları (pointer) en aza indirilmelidir
1.4- Giriş-çıkış ve grafik ile ilgili işlemlerde standart fonksiyonların kullanımı azaltılmalıdır
1.5- Program doğru çalışıyorsa Â«Range CheckingÂ» kaldırılmalıdır
1.6- Karşılaştırma ve koşullar en aza indirilmelidir
1.7- Kullanılacak algoritmalar doğru seçilmelidir

2- İŞLEMCIYE ÖZEL OPTIMIZASYONLAR
2.1- 486 cephesinde durum
2.2- Pentium ve Pentium MMX
2.3- Pentium Pro ve Pentium II

PASCAL'DA ASSEMBLY
Inline direktifi
Harici Prosedürler
Assembler direktifi ve asm...end blokları

Pascal ile Optimizasyon:

Giriş:

Pascal'da kaynak kodu optimizasyonu, günümüzdeki bilgisayarlarların hızlı olmasından ötürü Pascal ile program geliştiren kişilerin genelde gözönüne almadıkları ama programlarının yavaş bilgisayarlarda bile yeterli hızda çalışmasını isteyenlerin (oyun ve veritabanı programcıları vb.) yapmaları zorunlu olan birşeydir.
Optimizasyon işlemi genellikle kaynak kodun okunurluğunu azaltan tekniklerle kod yazmayı, hatta assembly ile yazılmış harici nesnelerin (.obj dosyaları) programa dahil edilmelerini gerektirebilir. Bu bakımdan, programın geliştirme aşamasında hemen optimizasyon yapılması zordur. Turbo ProfilerÂ® gibi bir programla yavaşlamaya sebep olan bölümlerin belirlenip iyileştirilmesi, programın geliştirilmesinde modüler yapının iyi kurulması gerekir.

Optimizasyon temelde iki türlüdür:
1- İşlemciden bağımsız optimizasyonlar
2- İşlemciye özel optimizasyonlar

1- İşlemciden bağımsız optimizasyonlar :
Doğrudan Pascal kodu üzerinde yapılabilecek RAM hafıza disk erişimi ile ilgili okuma yazma işlemlerinin iyileştirilmesi, ayrıca, değişik çevre birimleriyle daha etkili iletişim yollarının bulunup uygulanmasıdır.

Avantajları:
? Programın okunurluğundan fazla taviz verilmeden iyileştirme yapılmış olur.
? Programın değişik ortam ve işlemcilerde kullanılması mümkündür.

Dezavantajları:
? Çok yüksek hız artışları sağlanamayabilir.
? Programın çalışma hızı kullanılan derleyiciye bağlıdır.

Pascal kodunun iyileştirilmesinde bazen standart kütüphanenin (turbo.tpl) sunduklarını reddetmek ve özel kütüphaneler (üniteler) kullanmak gerekir. Bu kütüphanelerde interruptlar (kesmeler) kullanmak gerektiğinde mutlaka interruptlar hakkında yeterince bilgi edinmek veya kütüphaneyi güvenilir bir yerden almak iyi olur. Ayrıca, Pascal'da assembly kullanımı ile ilgili bölümü, hem işlemci ile ilgili, hem de işlemciden bağımsız optimizasyonlar için gerektiğinden okumakta fayda vardır.
Bazı tavsiyeler:

1.1- Hafıza aktarımlarını mümkün olduğunca büyük bloklar halinde yapmak doğru olur.

Örnek:
EGA/VGA renkli metin ekranı $B800 segmentinde adreslenir. Bu segmentte her word ekrandaki bir karakterin kodunu ve niteliğini içerir.
Aşağıda, bu adrese doğrudan veri yazarak ekranı o anda geçerli yazı niteliğindeki belli bir karakterle (Zkar parametresi) dolduran aynı işi yapan iki procedure vardır. İkinci procedure, veri atamalarını word paketleri halinde yaparak birinciye göre iki kat daha hızlı çalışan kod üretilmesini sağlar.

[COLOR=#c5003f]Satir ve Sutun ekrandaki satır ve sütun sayılarını içeren global değişkenlerdir.

Bu örnekler test amaçlı olarak yazdığım bir örnek programdan alınmıştır.

1. Procedure:

Uses Crt;
...
Procedure Zemin(Zkar:Char);
(* Atamalar 8 bit (byte) yapılıyor.
Program parçası anlaşılır şekilde yazılmış.
Optimizasyon yok. *)
Var
Q:Word;
Begin
For Q:=Satir*Sutun downto 0 do
begin
Mem[$B800:Q*2 ]:=Byte(Zkar);
Mem[$B800:Q*2+1]:=TextAttr;
end;
end;
...

2. Procedure:

Uses Crt;
...
Procedure Zemin(Zkar:Char);
(* Atamalar 16 bit (word) yapılıyor.
Program parçasının anlaşılırlığı azalmış.
Kaynak kodu optimizasyonu var. *)
Var
Q,Cift:Word;
Begin
Cift:=Byte(Zkar)+(TextAttr Shl 8);
For Q:=Satir*Sutun downto 0 do
MemW[$B800:Q Shl 1]:=Cift;
end;

İkinci prosedürün kaynak kodu optimizasyonu için ardışık iki atama yerine her seferde bir atama yapılmış, sabit tamsayıyla çarpma işlemleri Â«shlÂ» operatörüyle gerçekleştirilmiştir. Bu prosedür, 32-bit yazmaçlar ve atamalar kullanılarak daha da iyileştirilebilir.
Konuyla ilgili diğer önemli bir uyarı da Blockread ve Blockwrite ile ilgili. Bu prosedürler geniş arabellekle kullanılmalıdırlar. Arabellek boyutu 512 baytın katları olmalıdır. Örneğin 10.000 bayt arabellek yerine tam 10 kilobaytlık 10.240 bayt arabellek kullanılması performans açısından biraz daha iyidir. Ama en büyük performansı büyük arabellek verecektir.

1.2- String işlemleri için standart prosedürlerin yerine daha hızlı alternatifler bulunabilir
String tipi değişkenler, ilk Pascal derleyicilerinde karakter dizileri olarak tanımlanıyorlardı. Bir prosedürde parametre olarak kullanılmaları Â«stackÂ» bölümüne içerikleriyle kopyalanmalarına, dolayısıyla zaman ve yer kaybına yolaçıyordu. Bu sorun çok önceleri String tipi değişkenleri işaretçi (pointer) gibi kullanmakla halledildi. Derleyiciler artık parametre olan String değişkenlerin sadece adresini stack bölümüne atıyorlar, gerektiğinde bu adresten kullanıyorlar.
Yine de String ile ilgili atama ve kopyalama işlemleri çok hızlı değildir. Programda String tipindeki değişkenlerin sıklıkla kullanıldıkları bölümler varsa (isim sıralama, kelime işlem vb.) bu bölümleri optimize etmek mümkündür.

Örneğin, S ve D string, N bayt tipinde değişkenler olmak üzere, S'in ilk N karakterini D'ye aktarmak için
D:=Copy(S,1,N);

yazmak yerine

Move(S[1],D[1],N);
D[0]:=Chr(N);

ikilisini yazmak çok daha iyi sonuç verir.

[COLOR=#c5003f]Move komutu string tipi işlemlerde kullanmak için çok idealdir.

1.3- Genel değişkenler (global var.) ve işaretçi kullanımları (pointer) en aza indirilmelidir
Yerel (local var.) değişkenlere erişim genel değişkenlere olduğundan daha hızlıdır. Sayaç vb. değişkenlerin genel değişken olarak tanımlanmaları şart değildir. Bunları prosedür ve fonksiyonlar içinde geçici yerel değişkenler olarak tanımlamak daha iyi sonuç verir.

1.4- Giriş-çıkış ve grafik ile ilgili işlemlerde standart fonksiyonların kullanımı azaltılmalıdır
Grafik kütüphanesi ve giriş-çıkış komutları, standartlara ve tüm kullanıcıların donanımına uyumlu olmaları amacı güdülerek yazıldıklarından oldukça yavaştırlar.
Daha zahmetli de olsa, ilgili kesmelerden yararlanılarak grafik için Vesa uyumlu modlara erişerek bankları veya LFB'ı kullanacak şekilde programlamak, giriş-çıkış içinse ilgili portları ve işletim sisteminin olanaklarını kullanmak yerinde olur.

1.5- Program doğru çalışıyorsa Â«Range CheckingÂ» kaldırılmalıdır
Range Checking seçeneği, değişkenlere geçerli oldukları aralığın dışında bir değer atanıp atanmadığını kontrol eden kodları programa ekler. Bu kodlar karşılaştırma kodları oldukları için performansı olumsuz etkilerler. Programın hata ayıklama dönemi bitip doğru çalıştığından emin olununca seçenek devreden çıkarılmalıdır.

Kaynak kodu optimizasyonunda bir diğer önemli konu derleyici için iyileştirmeye uygun kod yazmaktır. Yakın zamanda geliştirilen derleyicilerin çoğu optimizasyon yeteneklerine sahipler.

Unutulmaması gereken diğer bir konu da yapılan optimizasyonu test etmektir. Performansa fazla katkı sağlamayan optimizasyon kodun okunurluğunu ve taşınırlığını boşuna azaltmış olur.

1.6- Karşılaştırma ve koşullar en aza indirilmelidir
Karşılaştırma komutları, geniş kapsamlı bir programda sıkça rastlanan komutlardır. Ama işlemci için bu tür komutlar, düz bir yoldaki yol ayrımlarıdır; işlemcinin hangi yola sapacağına karar vermesi yavaşlamaya sebep olacaktır.
Günümüz işlemcilerinin karşılaştırma komutlarının sonucunu kestirmek ve böylece bu tür komutların hız kesmesini önlemek için kullandıkları dallanma tahmini yöntemleri, eğer yapılan tahmin yanlışsa boşa harcanan saat çevrimlerine yolaçar. Aşağıdaki iki yapı aynı işi yapmalarına karşın uygulamada, eğer mümkünse, ikincisi tercih edilmelidir. Birinci yapı bahsedilen mahsurlu duruma yolaçabilir.

1. IF (Koşul) THEN A_iSLEMi
ELSE B_iSLEMi;

2. B_iSLEMi;
IF (Koşul) THEN
begin
Geri_Al_B_iSLEMi;
A_iSLEMi;
end;

1.7- Kullanılacak algoritmalar doğru seçilmelidir
Bazı bilinen algoritmalarda aynı işi yapanlardan hangisinin daha hızlı çalıştığı malumdur. Örneğin Quicksort sıralama yöntemi, Bubble sort yönteminden çok daha hızlı çalışır. Programcı, kendi geliştirdiği algoritmanın daha etkin hale getirilmesinin mümkün olup olmadığını araştırmalı, mümkünse algoritmasını iyileştirmelidir.

2- İşlemciye özel optimizasyonlar :
İşlemcinin özelliklerinin ve varsa ilave komut setlerinin etkili bir şekilde kullanılmasıdır. Örnek olarak Pentium ve üstü işlemcilerin aynı anda iki bağımsız komutu işleme özelliğinin kullanılması için Â«pairingÂ» yapma veya bir çoklu ortam (multimedia) uygulamasında MMX™ komut setininin avantajlarından faydalanmak verilebilir.

Avantajları:
? Mümkün olan en hızlı program kodu geliştirilebilir.
? Yeni teknolojilerden yararlanılabilir.

Dezavantajları:
? Bu tür optimizasyonları her Pascal derleyicisi yapmadığı için assembly ile programa dahil etmek gerekecektir.
? Fazladan çaba, zaman ve yeterli bilgi gerektirir. Programcı, işlemcinin özelliklerini ve çalışma prensiplerini bilmelidir.
? Program, yapılan işlemciye özel optimizasyonlar yüzünden her işlemcide çalışmayabilir. Bu durumda çalışma kütüphanelerinin bazı bölümlerinin normal ve optimize olarak iki biçiminin bulundurulması ve gerekenin çalıştırılması zorunludur. Örneğin, MMX için optimizasyonlar yapılmışsa programı Pentium™ ve Pentium Pro™ 'da çalıştırmak için optimize edilmemiş normal kütüphaneye ihtiyaç duyulacaktır. Ayrıca Intel, AMD, Cyrix ve diğer üreticilerin işlemci tasarımları değişik olduğundan ötürü her işlemcide aynı oranda iyileştirme yapılamayabilir.

Çoğunluğun kullandığı x86 temelli bilgisayarları gözönüne alacak olursak, tümü için geçerli bir optimizasyon tekniği yoktur. İşlemcilerin çalışma prensiplerine göre teknikler değişir. Ama bugünkü uygulamada, Pentium için optimize edilmiş bir program daha üst seviye işlemciler için de az veya çok optimize edilmiş sayılabilir.
İşlemcilerin işleyişini gözönüne alarak programları optimize etmek oldukça zahmetli bir iştir. Esasen bu derleyici yazanların ve low-level programcıların işidir. Burada temel bazı işlemci işleyiş ve Pascal'da assembly kullanım bilgileri verilecektir.

2.1- 486 cephesinde durum:
Intel'in x86 komut setinde ilk köklü değişikliği yapıp 32-bit yazmaçlar (register) ve komutlar eklediği işlemcisi 80386'dan sonra piyasaya sürdüğü, uzun süre piyasada kalan ve çeşitli çekirdek (CPU) hızlarında birçok değişik modelleri (SX, DX, DX2, DLC vs.) çıkan, zamanının başarılı bir işlemcisidir. Çoğu durumda bir saat çevriminde bir komut işleyecek şekilde tasarlanmıştır.

486 işlemciler 5 aşamada komut işlemektedirler.
1- Prefech : Komutların işlemci iki 16 baytlık arabelleğinden birine alınır.
2- Decode : Komut yolundan gelen komutların çözümlemesi yapılır.
3- Address Generation : Adres çözümlemesi yapılır.
4- Execution : Komutun çalıştırılması bu aşamada olur.
5- Writeback : Yazmaç içeriklerinin güncellendiği bölümdür.

2.2- Pentium ve Pentium MMX:
Pentium işlemciler, kendilerinden önceki nesillere göre komut işleme kapasitelerindeki büyük gelişme ile dikkat çektiler. Bu gelişme sayesinde birçok uygulamada aynı saat hızında Pentium işlemci 486 işlemciden en az iki kat daha hızlı komut işliyordu. Bu gelişmenin en önemli sebepleri:
- Dallanma tahmini (Branch prediction) : Dallanma (jump) komutlarında işlemcinin birtakım tahminler yapmak yoluyla dallanmanın yolaçtığı gecikmeleri azaltmasıdır.
- Çift pipeline : Komutların U ve V ile sembolize edilen iki pipeline (komut yolu) içinde eşzamanlı olarak işlenmesi sayesinde teorik olarak aynı anda iki komut işlenmesidir. Pratikte bunun gerçekleşebilmesi bazı şartların sağlanması gerekir.
- Yeni kayan nokta işlem ünitesi : Pentium, gerçel sayı işlemlerinin hızını belirgin bir şekilde arttıran yeni matematik işlemci tasarımıyla kendi dönemindeki x86'ların önemli bir yavaşlığı telafi etti.

Pentium MMX işlemci, klasik Pentium'a göre biraz daha iyi komut işler. Daha geniş L1 arabellek, daha iyi dallanma tahmini algoritması ve yeni komut seti eklentileri ona avantaj sağlar.

Pentium için optimizasyonda Pascal kodu içinden yapılabilecek en önemli etki, inline veya asm bloklarını çift pipeline mimarisinin kurallarına uyarak optimize etmektir. İşlemciye aynı anda iki komut işletebilmenin yolu mümkün olduğunca uygun komut çiftleri oluşturmaktır. Pentium'un pipeline'ını oluşturan yollar U ve V yolları olarak adlandırılır. U yolu tüm komutları işleyebilirken V yolu bazı sıkça kullanılan basit yapılı komutları işleyebilir. Bu yolların etkin kullanımı, komutların uygun sırayla işlemciye ulaştırılmasıyla olur.

Bazı eski karmaşık yapılı komutlar, komut çiftlemeyi mümkün kılacak şekilde eşder komutlara bölünebilirler.

Örneğin,
MOVZX EAX,BYTE PTR [...] = XOR EAX,EAX + MOV AL,BYTE PTR [...]

Temel kurallar şunlardır:

1- Her iki komut basit yapıda olmalıdır. Komutları, Pentium'un işleyişi bakımından 4'e ayırmak mümkündür:
UV (Hem U'da hem V'de çiftlenebilen),
PU (U'da çiftlenebilen),
PV (V'de çiftlenebilen,
NP (çiftlenemeyen)

UV : MOV, PUSH, POP yazmaç, LEA, NOP, INC, DEC, ADD, SUB, CMP, AND, OR, XOR,
A.L.U. yazmaç,... , A.L.U. adres,yazmaç/değer, NOP, TEST(kısmen)
PU : ADC, SBB, SHR, SAR, SHL, SAL yazmaç,değer , ROR, ROL, RCR, RCL yazmaç,1
PV : yakın CALL, JUMP, koşullu dallanma komutları.

Bunların dışındaki komutlar U yolunda işlenir ve çiftlenemezler.

2- İki komut arasında yazmaç bağlılığı bulunmamalıdır. Yani bir komut kendinden öncekinin sonucunu beklemek zorunda olmamalıdır. Örnekler:

MOV BX,CX ; ADD AX,BX ' ikinci komut birincide BX'in alacağı değere bağlı, çiftlenemez!
MOV BX,CX ; MOV CX,AX ' ikinci komut birinciyi beklemeden işlenebilir.
CMP AX,5 ; JA _etiket ' karşılaştırma ve dallanma komutları bu şekilde çiftlenebilir.

3- Genellikle, önekli komutlar U'da işlenir ve çiftlenemezler.

Pentium için optimize edilen programlar, işlemci çalışma prensiplerinden ötürü daha eski işlemcilerde normalden de yavaş çalışabilirler. Bunun sebebi, eski karmaşık yapılı komutların aynı anlama gelen komutlara ayrılmasıyla komut çiftleme imkânı oluşturmak, Pentium işlemcilerde hız kazandırırken eski tip işlemcilerde kaybettirebilir. Günümüzde pek önemi kalmayan bu durum bir uyarı niteliğindedir.

2.3- Pentium Pro ve Pentium II :
Mimarileri ve komut işleme teknikleri çok benzer olan olan bu iki işlemci, üç komutu aynı anda işleme yeteneğine sahiptir. Bunun dışında, gelişkin dallanma tahmini, yazmaç isimlerini otomatik değiştirme, sırasız komut işleme gibi çok etkili yöntemlerle çalışırlar. Pentium II, MMX desteği, 16-bit programları daha iyi işlemesi ve yeni veriyolu mimarisi ile Pentium Pro'dan ayrılır.
Pentium Pro ve PII'nin komut yollarını D0, D1, D2 diye adlandırırsak, D0 Pentiumlardaki U'ya, diğerleri V'ye karşılık gelir. Komutların uygunlaştırılması üçlü halde yapılır. Bununla birlikte Pentium için optimize edilen program bu işlemcilerde de normalden hızlı çalışacaktır.

Bu anlatılanların işlemci özelliklerinin bazı eksikleri ve belirtilmemiş istisnalar vardır. Genel durum, belirtildiği şekilde olup ayrıntılara girilmemiştir.

Pascal'da Assembly:
Derleyiciler herzaman en uygun kodu üretmezler, hatta birçoğu eski işlemcilerle olan uyumluluğu bozmamak için yeni işlemcilerde oldukça Â«müsrifÂ» davranan komutları üretebilirler. Ayrıca hafıza erişimi bolca olan ya da matematiksel işlem yapan kodların optimize edilmesi genellikle mümkündür. Derleyicinin yapamadığı yerde bunu programcı, kodunu assembly komutlarıyla destekleyerek yapar.
Assembly komutları Pascal programlarına üç yoldan eklenebilir:
1- Inline komutuyla doğrudan, derlenmiş byte kod olarak,
2- Assembler'da Pascal modeliyle derlenmiş .obj dosyaları yoluyla,
3- TP6'dan itibaren Assembler direktifi ile tüm prosedürde veya asm ... end bloğu arasında 16-bit 80286 komutları olarak.

Inline direktifi:
İşlemciye gönderilecek komutları hazır olarak programa katmak için kullanılır. Bir prosedür için uygun olan herhangi bir yerde yazılabilir. Kullanımı dikkat ve biraz bilgi ister. Normalde derleyicinin destekle-mediği komutları bu sayede programa eklemek mümkün olur. Bugünkü uygulamada bundan başka avantajı kalmamıştır. Bu direktif hakkında ayrıntılı bilgi bu yazıda verilmeyecektir.
Assembly komutlarının karşılığı olan byte kodları Debug veya herhangi bir disassembler program yardımıyla elde ettikten sonra ardışık / ile ayrılmış baytlar şeklinde parantezin arasına yazmak gerekir.
Inline($A1/$FF/$F0); veya aynı anlamda Inline($A1/$F0FF); komutu MOV AX,$FFF0 komutunun karşılığı olarak programa dahil edilebilir. Görüldüğü gibi, word değerlerin bayt halinde yazılması sırasında yüksek ve düşük baytların ters sırada yazılması gerekir.

Harici Prosedürler:
Pascal modeline göre derlenmiş assembly program parçaları .obj dosyaları halinde programa dahil edilebilir, programın içindeki veriyi kullanabilir.

Assembler direktifi ve asm...end blokları:
Kullanılan derleyiciye bağlı olarak kaynak kodu içinde assembly komutları ve prosedürleri kullanılabilir. Çok yaygın derleyicilerden Borland Pascal 6 ve 7'de 286/287 komutları, TMT Pascal'da 386/387 komutları desteklenmektedir.
Genel kullanımı şu şekildedir:

Procedure ProcName( {parametreler} );Assembler;
asm
... {Assembly komutları}
end; {Prosedür sonu}

Sözkonusu olan fonksiyonlar olduğunda da aynı yapı geçerlidir.
Prosedür ve fonksiyonların değer parametreleriyle yazmaçlar arasındaki alışverişi parametreleri doğrudan boyutuna uygun yazmaca atanarak yapılabilir. Adres içeren parametrelerde ve fonksiyonlardan dönecek değerlerde dikkat edilecek noktalar vardır.

Küçük bir hatırlatma: Prosedürlerin veya fonksiyonların parametreleri değer parametresi veya değişken parametresi olabilir.
Procedure EkrandanSatirOku( X,Y,U : Byte; Var Str:String);
Bu prosedürün görevi, metin ekranındaki X,Y koordinatından U uzunluğundaki bilgiyi okuyup Str string değişkenine aktarmak olsun. Buradaki X,Y ve U değer parametreleridir, değişmezler, Str ise değişken parametresidir, prosedür içinde değeri değişerek çıkabilir.

Bu prosedür çağırılırken
EkrandanSatirOku(4,5,N,S);
şeklinde çağırılabilir,
EkrandanSatirOku(4,5,N,'ABC');
şeklinde çağırılamaz!
Çünkü, değer parametrelerine değişken konabilir ama değişken parametrelerine (var ile tanımlı parametrelere) değer konamaz.
Adres içeren parametreler, pointer, string, dizi (array) tipinde olan değer parametreleri ve tüm değişken parametreleridir. Bunların 4 baytlık (segment ve ofsetli) adresleri alınıp asm...end bloğunda işlenirler.
Fonksiyonlarda ise, fonksiyonun geri dönecek değeri, tanımlanan tipine göre Byte, Shortint veya Char ise AL'de, Word veya Integer ise AX 'de, Longint veya Pointer ise AXX 'de saklanır.
Ayrıca çok kullanılan bazı assembly komutlarını hatırlatmakta fayda var:

( y:yazmaç, a:adres, d:değer, @ıçrama komutları için ofset )
- MOV y/a, y/a/d
- AND, OR, XOR y, y/a
- NOT, NEG y/a
- SHL, SHR, ROL, ROR y/a, y/d
- LEA y, [y+d]
- JMP @
- JA, JZ, JE, JB, JNA, ... @
- TEST, CMP y/a, y/a/d

Yukarıdaki komutlarda Â«a, aÂ» kombinasyonu geçerli değildir. Ayrıca adres ve yazmaç kullanımı ile ilgili de kısıtlamalar vardır. Örneğin SHL DX,CL geçerli ama SHL DX,CX geçersizdir!

Tüm bu bilgilerin ışığında, bir string değişkenin N. karakterinin Ascii kodunu veren bir fonksiyon yazılabilir:

Function Ascii(Var S:String; N:Byte):Byte;Assembler;
asm
LES DI, S[0] { 1: S'in başlangıç adresi ESI'a depolanır }
XOR BX,BX { 2: BX yazmacı sıfırlanır }
XOR AX,AX { 3: AX yazmacı sıfırlanır }
MOV BL, N { 4: Kaçıncı karakter hesaplanacağı BL'ye }
MOV AL,ES:[DI] { 5: S'in uzunluğunu içeren ilk bayt AL'ye aktarılır }
CMP AL,BL { 6: AL, BL ile karşılaştırılır }
JB @1 { 7: AL'de bulunan S'in uzunluğu N'den küçükse işlem yapılamaz}
MOV AL,ES:[DI+BX] { 8: N. karakter AL'ye aktarılır }
JMP @2 { 9: Fonksiyonun sonucu AL'de }
@1:XOR AL,AL {10: İşlem mümkün değilse fonksiyondan sıfır değeri döner}
@2: {11: Bitti!.. }
end;

Bu fonksiyon, esasen Ord(S[N]) ifadesiyle aynı görevi görmesine rağmen konuya iyi bir örnek oluşturduğu için yazılmıştır. S'in ESI'a aktarılan adresi, sıfırıncı baytını yani uzunluğunu içerir. Uzunluğu N'den küçükse, fonksiyonun istenen karakterin değerini vermesi mümkün değildir. Bu durumda AL değerinin sıfırlanarak fonksiyonun terkedildiği @1 etiketine dallanma yapılır ve fonksiyondan sıfır değeri döner. S'in uzunluğu N'den büyük veya eşitse işlem mümkündür, AL'ye N. karakterin aktarılması ile işlem tamamlanır. Bu da şöyle gerçekleşir: N'in değerinin 4. Satırdan beri BX'de olduğunu biliyoruz. S[0]'ın adresi ES:[DI] idi. Bu adresten BL yani şimdi BX kadar uzakta olan bayt, N. bayttır. Bu bayt AL'ye 8. Satırda aktarılır ve fonksiyon görevini yerine getirmiş olur.

Sözün kısası...
Optimizasyon konusu, donanımın yazılıma göre daha hızlı gelişim göstermesi yüzünden pek üzerinde durulmayan ama tecrübeli programcıların gözardı etmedikleri bir konudur. Aynı işi yapan iki rakip programdan daha hızlı olanının, daha düşük konfigürasyonda iyi çalışanın tercih edilmesi olasılığı yüksektir. Ayrıca disk gibi depolama birimlerinin hızı konusunda pek az gelişme oluyor. Dosya işlemlerinin optimizasyonu halen önem taşıyan bir konudur.
Pascal’ı ve Intel işlemcilerini baz alarak yazılan bu yazıdaki bilgilerin daha kaliteli programların gelişmesine katkıda bulunmasını dilerim.

alıntıdır

Matematiksel İşlem Programı

Thu, 04 Dec 2008 16:57:05 +0200

Menu secenekli güzel ve basit bir program

uses crt;
label d;
var
a:byte;
sec,devam:char;
s1,s2:longint;
sonuc:real;
begin clrscr;
d:
for a:=5 to 75 do begin
textcolor(3);gotoxy(a,5);write(#205);
gotoxy(a,20);write(#205);
gotoxy(a,7);write(#205);
end;
for a:=5 to 20 do begin
gotoxy(5,a);write(#186);
gotoxy(75,a);write(#186);
gotoxy(5,5);write(#201);
gotoxy(5,20);write(#200);
gotoxy(75,5);write(#187);
gotoxy(75,20);write(#188);
end;
for a:=10 to 30 do begin
gotoxy(a,10);write(#205);
gotoxy(a,18);write(#205);
end;
for a:=45 to 65 do begin
gotoxy(a,10);write(#205);
gotoxy(a,18);write(#205);
end;
for a:=10 to 18 do begin
gotoxy(10,a);write(#186);
gotoxy(30,a);write(#186);
gotoxy(45,a);write(#186);
gotoxy(65,a);write(#186);
gotoxy(10,18);write(#200);
gotoxy(10,10);write(#201);
gotoxy(65,18);write(#188);
gotoxy(65,10);write(#187);
gotoxy(45,10);write(#201);
gotoxy(45,18);write(#200);
gotoxy(30,10);write(#187);
gotoxy(30,18);write(#188);
end;
for a:=25 to 50 do begin
gotoxy(a,24);write(#205);
end;
for a:=21 to 24 do begin
gotoxy(25,a);write(#186);
gotoxy(50,a);write(#186);
gotoxy(25,20);write(#201);
gotoxy(25,24);write(#200);
gotoxy(50,24);write(#188);
gotoxy(50,20);write(#187);
end;
textcolor(yellow);gotoxy(26,6);write('--------> MENU <---------');
TEXTCOLOR(lightgreen);gotoxy(12,11);write('[a] TOPLAMA');
gotoxy(12,13);write('[b] CIKARMA');
GOTOXY(12,15);write('[c] CARPMA');
GOTOXY(12,17);write('[d] BOLME');
GOTOXY(47,11);Write('[e] KARE');
GOTOXy(47,13);write('[f] FAKTORIYEL');
GOtoxy(47,15);write('[g] KAREKOK');
gotoxy(47,17);write('[h] DA˜RE ALAN ');
GOTOXY(30,22);write('Seciminiz....:');
SEC:=READKEY;
case sec of
'a': begin clrscr;
for a:=20 to 60 do begin
gotoxy(a,10);write(#205);
gotoxy(a,20);write(#205);
end;
for a:=10 to 20 do begin
gotoxy(20,a);write(#186);
gotoxy(60,a);write(#186);
gotoxy(20,10);write(#201);
gotoxy(20,20);write(#200);
gotoxy(60,10);write(#187);
gotoxy(60,20);write(#188);
end;
textcolor(3);gotoxy(25,11);write('------>>>>TOPLAMA<<<<----------');
gotoxy(30,14);write('1.sayi...:');readln(s1);
gotoxy(30,16);write('2.sayi...:');readln(s2);
sonuc:=s1+s2;
gotoxy(30,18);write('sonuc...:',sonuc:3:2);
end;
'b':begin clrscr;
for a:=20 to 60 do begin
gotoxy(a,10);write(#205);
gotoxy(a,20);write(#205);
end;
for a:=10 to 20 do begin
gotoxy(20,a);write(#186);
gotoxy(60,a);write(#186);
gotoxy(20,10);write(#201);
gotoxy(20,20);write(#200);
gotoxy(60,10);write(#187);
gotoxy(60,20);write(#188);
end;
textcolor(3);gotoxy(25,11);write('------>>>>CIKARMA<<<<----------');
gotoxy(30,14);write('1.sayi...:');readln(s1);
gotoxy(30,16);write('2.sayi...:');readln(s2);
sonuc:=s1-s2;
gotoxy(30,18);write('sonuc...:',sonuc:3:2);
end;
'c':begin clrscr;
for a:=20 to 60 do begin
gotoxy(a,10);write(#205);
gotoxy(a,20);write(#205);
end;
for a:=10 to 20 do begin
gotoxy(20,a);write(#186);
gotoxy(60,a);write(#186);
gotoxy(20,10);write(#201);
gotoxy(20,20);write(#200);
gotoxy(60,10);write(#187);
gotoxy(60,20);write(#188);
end;
textcolor(3);gotoxy(25,11);write('------>>>>CARPMA<<<<----------');
gotoxy(30,14);write('1.sayi...:');readln(s1);
gotoxy(30,16);write('2.sayi...:');readln(s2);
sonuc:=s1*s2;
gotoxy(30,18);write('sonuc...:',sonuc:3:2);
end;
'd':begin clrscr;
for a:=20 to 60 do begin
gotoxy(a,10);write(#205);
gotoxy(a,20);write(#205);
end;
for a:=10 to 20 do begin
gotoxy(20,a);write(#186);
gotoxy(60,a);write(#186);
gotoxy(20,10);write(#201);
gotoxy(20,20);write(#200);
gotoxy(60,10);write(#187);
gotoxy(60,20);write(#188);
end;
textcolor(3);gotoxy(25,11);write('------>>>>BOLME<<<<----------');
gotoxy(30,14);write('1.sayi...:');readln(s1);
gotoxy(30,16);write('2.sayi...:');readln(s2);
sonuc:=s1/s2;
gotoxy(30,18);write('sonuc...:',sonuc:3:2);
end;
'e':begin clrscr;
for a:=20 to 60 do begin
gotoxy(a,10);write(#205);
gotoxy(a,20);write(#205);
end;
for a:=10 to 20 do begin
gotoxy(20,a);write(#186);
gotoxy(60,a);write(#186);
gotoxy(20,10);write(#201);
gotoxy(20,20);write(#200);
gotoxy(60,10);write(#187);
gotoxy(60,20);write(#188);
end;
textcolor(3);gotoxy(25,11);write('------>>>>KARE<<<<----------');
gotoxy(30,14);write('Bir sayi girin...:');readln(s1);
sonuc:=s1*s1;
gotoxy(30,16);write('sonuc...:',sonuc:3:2);
end;
'f':begin clrscr;
for a:=20 to 60 do begin
gotoxy(a,10);write(#205);
gotoxy(a,20);write(#205);
end;
for a:=10 to 20 do begin
gotoxy(20,a);write(#186);
gotoxy(60,a);write(#186);
gotoxy(20,10);write(#201);
gotoxy(20,20);write(#200);
gotoxy(60,10);write(#187);
gotoxy(60,20);write(#188);
end;
textcolor(3);gotoxy(25,11);write('------>>>>FAKTORIYEL<<<<----------');
gotoxy(30,14);write('Bir sayi girin...:');readln(s1);sonuc:=1;
for a:=1 to s1 do begin
sonuc:=sonuc*a;
gotoxy(30,18);write('sonuc...:',sonuc:3:2);
end;end;
'g':begin clrscr;
for a:=20 to 60 do begin
gotoxy(a,10);write(#205);
gotoxy(a,20);write(#205);
end;
for a:=10 to 20 do begin
gotoxy(20,a);write(#186);
gotoxy(60,a);write(#186);
gotoxy(20,10);write(#201);
gotoxy(20,20);write(#200);
gotoxy(60,10);write(#187);
gotoxy(60,20);write(#188);
end;
textcolor(3);gotoxy(25,11);write('------>>>>KAREKOK<<<<----------');
gotoxy(30,14);write('Bir sayi girin...:');readln(s1);
sonuc:=sqrt(s1);
gotoxy(30,18);write('Sayinin karekoku...:',sonuc:3:2);
end;
'h':begin clrscr;
for a:=20 to 60 do begin
gotoxy(a,10);write(#205);
gotoxy(a,20);write(#205);
end;
for a:=10 to 20 do begin
gotoxy(20,a);write(#186);
gotoxy(60,a);write(#186);
gotoxy(20,10);write(#201);
gotoxy(20,20);write(#200);
gotoxy(60,10);write(#187);
gotoxy(60,20);write(#188);
end;
textcolor(3);gotoxy(25,11);write('---->>>>DA˜REN˜N ALANI<<<<----');
gotoxy(25,14);write('Dairenin yarÂcapini girin...:');readln(s1);
sonuc:=s1*pi;
gotoxy(30,18);write('Dairenin alanÂ...:',sonuc:3:2);
end;
end;
tEXTCOLOR(RED);gotoxy(25,25);write(#205,'COPYRIGHT TO By ZIYANKAR',#205);
gotoxy(20,21);write('DEvam etmek istiyormusunuz....[e/h]:');devam:=readkey;
clrscr;
if devam='e' then goto d
else exit;
readln;
end.

alıntıdır

sayıların ortalamasını alma

Thu, 04 Dec 2008 16:56:02 +0200

istediginiz sayıda girdiginiz sayıların ortalamasını almak için yazılmış bir program var a,i:integer;
toplam,ortalama,b:real;
begin
write('kaç tane sayinin ortalamasini almak istiyorsunuz=');
readln(a);
toplam:=0;
for i:=1 to a do
begin
write(i,'.sayiyi giriniz='); readln(b);
toplam:=toplam+b;
end;
ortalama:=toplam/a;
writeln(a,'tane sayinin ortalamasi=',ortalama:10:2);
end.

Kayan Yazı

Thu, 04 Dec 2008 16:55:10 +0200

Klavyeden Girilin Bir kelimenin Ekreanın Ortasından Kayarak İnme... uses Crt;
var
i,hiz,ses:integer;adtring;
begin clrscr;
TEXTBACKGROUND(2);textcolor(15);
gotoxy(1,1);write('KAYACAK OLAN YAZIYI GİRİNİZ...:');readln(ad);
gotoxy(1,2);write('LÜTFEN GİRİS HIZINI GİRİNİZ...:');readln(hiz);
gotoxy(1,3);write('LÜTFEN BELİRTİLENARALIKTA SES KODUNU GİRİNİZ...(1 ila 1000 arasi)...:');readln(ses);
clrscr;
gotoxy(1,1);writeln('PROGRAMDAN ÇIKMAK İÇİN LÜTFEN HERHANGİ BİR TUŞA BASINIZ VE YAZININ SAĞ TARAFA GEÇMESİNİ BEKLEYİNİZ....');
repeat
for i:=1 to 70 do begin
textcolor(14);
gotoxy(i+1,20);Write(ad);
sound(ses);
delay(hiz);
textcolor(black);
gotoxy(i+1,20);Write(ad);
end;
until keypressed;
nosound;
write('yusuf baydoğan tarafından hazırlanılmıştır. çalışmalarımzın devamı gelecektir');
readln; end.

[yazının rengi siyah değilse textcolor komutunun yanındaki sayıyı değiştiriniz ama unutmayın sadece 1-16 arasında sayı girilebilir başarılar]

copyy

Thu, 04 Dec 2008 16:54:35 +0200

metin dosyasının diğerine kopyalanması program ornek;
var
d1,d2:TEXT;
a:char;
begin
ASSIGN(d1,'c:\ornek.txt');
ASSIGN(d2,'C:\odev.txt');
Reset(d1);
while not eof(d1) do
begin
read(d1,a)
write(d2,a);
end;
close(d1);
close(d2);
end.