Bu yazımızda C / C++ ve Delphi gramer bilgisi vermek yerine, daha çok C / C++ kodlarını en doğru şekilde Delphi’ye nasıl adapte edebileceğimizi göreceğiz. Yapacağımız işlem sadece bire bir kod çevirisi olmayacak. Yeri geldiğinde hiç bir kod çevirmeden sadece orjinal kütüphaneyi Delphi programımızın içine gömebileceğiz.

Eğer siz de, ister derlenmiş olsun, ister açık kaynak kodlu olsun, bir C / C++ kütüphanesini Delphi’ye nasıl çevirebileceğimizi merak ediyorsanız buyurun beraber yazımıza giriş yapalım.

Giriş

C / C++ ‘dan Delphi’ye kod çevirme derken ilk akla gelen, binlerce satırlık C kodlarını teker teker uğraşıp Delphi olarak yazmak gelecektir. Halbuki bu en son tercihimiz olması gerekmektedir. İlerleyen bölümlerde de göreceğimiz gibi, Delphi derleyicisinin hünerli parmakları bizi bir çok dertten kurtarmaktadır. Yine de bütün kodları baştan çevirmek gibi bir derdin altına girmek isterseniz bu makale size bir başlangıç noktası olacaktır.

Hemen kodlara dalmak gerçekten gerekli mi? Kesinlikle gerekli değil. Çünkü bizim uğraştığımız şey, önceden birileri tarafından yapılıp internet üzerinde dağıtılıyor olabilir. Bu yüzden ilk yapacağımız işlem bir “Delphi port” bulmamız gerekmetedir.

Mesela şuanda en hızlı ve en stabil xml kütüphanesi kabul edilen libxml2 kütüphanesini kullanmak istediğimizde, hemen kodları çevirmeye kalkmak yerine bir Delphi port bulmamız en akıllıca işlem olacaktır. Ki bu kütüphanenin başlık dosyaları zaten sourceforge üzerinde dağıtılmaktadır.

Bu makalede, C objelerinin kullanımı, C veri tiplerinin Delphi’deki karşılıkları, C başlık (header .h) dosyalarının Delphi’ye çevrilmesi gibi bir çok konu bulacaksınız. Bu bilgiler ile istediğiniz bir C kütüphanesini korkmadan Delphi’ye adapte edebilirsiniz.

Bu makalede çok fazla C / C++ bilgisi gerekli mi? Gerekli olsa bu makaleye ihtiyaç duymazdınız. Fakat çok  az da olsa C / C++ gramerine aşinalığınız olmak zorunda. En basit olarak bir bir fonksiyon nasıl tanımlanır, bir değişken nasıl tanımlanır, bir pointer nasıl atanır, bunları bilmeniz gerekmektedir.

Fonksiyon Çağırım Mekanizmaları

Bir çinli ile anlaşabilmek için bir tercüman tutmanız gerekti. Fakat çok aramanıza rağmen çinli bir tercüman bulamadınız. Bunun yerine bir birine benziyor diye kalkıp, japonca bir tercüman tuttunuz. Çinli olan birisi ile ne kadar anlaşabilirsiniz. Her ne kadar bize “benzer” gibi gözükse de iki dil bir birinden farklı dildir. Bu örneği şimdi göreceğimiz konuya hazırlamak için verdim. Bu misalden hakikate şu şekilde geçebiliriz. Derlenmiş olan her bir kütüphanedeki fonksiyonlar belli bir dili konuşmaktadırlar. Bu konuştukları diller görünüşte bir birlerine benzeseler de, ayrıntıda bir birlerinden farklıdırlar. Bu konuşulan dillere fonksiyon mekanizmaları ya da ingilizce terim olarak “calling conventions” denilmektedir. Eğer kullanacağınız fonksiyon farklı bir dili kullanıyor ve siz de fonksiyonu farklı bir dil ile çağırıyorsanız muhtemel hatalar ile karşılaşacaksınız. Bu yüzden ilk öğreneceğimiz konu bu olmalıdır.

Direk olarak çağırım mekanizmalarının delphi karşılıklarını vermek yerine az da olsa bir kaç özelliklerinden bahsetmek istiyorum. Çünkü hangi çağırımı nerede ne için kullanacağımızı bilmemiz şarttır.

Şu an literatürde en çok kullanılan 4 çeşit fonksiyon çağırım mekanizması vardır. Bunların ne olduğunu ayrıntısı ile anlatan buradaki makalemize göz atabilirsiniz. Hatta okumadı iseniz bir göz gezdirmenizi şiddetle tavsiye ediyorum. Biz burada bu mekanizmaların çalışma şekillerinden çok işimize yarayan kısmını anlatmaya çalışacağız. Ama linkini verdiğim makalede bunların çalışma şekillerini ayrıntılı bir şekilde bulabilirsiniz.

Birinci olarak göreceğimiz çağırım mekanizması register çağırımıdır. Delphi varsayalın olarak bütün fonksiyon ve metodlarda bu çağırımı kullanmaktadır. Normalde Dehlpi’de “register” ayrılmış kelimesini fonksiyon ya da metodun sonuna eklemekle, fonksiyon ya da metodu bu çağırım için ayarlamış oluruz. Fakat varsayılan olarak kullanıldığı için bunu yazmanıza gerek yoktur:

procedure RegisterCagirimliProcedure; register;

Fonksiyon çağırım mekanizmaları ile ilgili yazıyı okuduysanız en verimli ve performanslı çağırımın bu olduğunu biliyorsunuzdur. Bu mekanizma ilk olarak Borland tarafından geliştirilip C++ Builder ve Delphi derleyicilerinde kullanıldı. Şu anda bildiğim bütün C / C++ derleyicileri bu çağırımı desteklemektedir. C / C++ derleyicilerinde bu çağırım __fastcall olarak isimlendirilmektedir.

Her ne kadar en hızlı çağırım __fastcall yani register olsa da ve çoğu derleyici tarafından desteklense de, belki de alışkanlıklardan dolayı, C / C++’da pek kullanılmamaktadır. Genelde Linux ve Windows’da ileride gelecek olan başka çağırımlar kullanılmaktadır.

__fastcall yani register çağırımları, Microsoft’uın derleyicilerinde __msfastcall olarak başka bir biçimi de almıştır. Fakat şu anda Delphi bu çağırımı desteklememektedir. Umarım ilerideki Delphi derleyicilerinde bunu görebiliriz. Fakat bu çağırım __fastcall kadar bile yaygın ve fazla kullanılmadığı için şu anda anlattığımız çevirim işlemi için çok da önemli değil. Hatta, eğer bir kütüphane bir çok dili desteklemek gibi bir gayesi varsa __fastcall çağırımını da desteklememektedir.

Kısacası bu çağırımı delphi’ye aktarmak için hiç bir şey yapmamız gerekmiyor. Çünkü delphi bunu varsayılan olarak kullanıyor. Mesela aşağıdaki C fonksiyonunu delphi’ye çevirelim:

__fastcall int birFonksiyon(int i);

function BirFonksiyon(i: Integer): Integer;

İkinci çağırım mekanizmamız __pascal yada delphi’de pascal çağırımıdır. Ki bu çağırım Win 3.1 zamanından kalma eski bir çağırımdır. Bu yüzden eğer karşılaşırsanız yapmanız gereken __pascal yerine pascal yazmalısınız.

Üçüncü çağırım mekanizmamız __stdcall ya da delphi’de stdcall çağırımıdır. Bu çağırım, Windows işletim sisteminin varsayılan çağırım mekanizmasıdır. Eğer windows’a ait bir DLL’i kullanacaksak, bilinki %99 stdcall olarak tanımlanmıştır. __stdacall çağırımı derleyicilerde çeşitli takma adlar ile kullanılmaktadır. Genelde “WINAPI” kelimesi __stdcall için kullanılmaktadır. Mesela aşağıdaki Windows API’sinden bulunan fonksiyonu şöyle çevireceğiz:

WINAPI BOOL ReleaseCapture(VOID);

function ReleaseCapture: Boolean; stdcall;

Yardım dosyalarında bu fonksiyonun başında WINAPI ya da __stdcall ifadesini görmesek de, biliyoruz ki bu bir Windows fonksiyonudur. Öyleyse bu fonksiyon stdcall çağırımıdır. Bu çıkarım ile hem delphi hem de C kodunda bu çağırımı belli ettim.

Dördüncü ve son çağırımımız ise __cdecl ya da delphi’de cdecl çağırımıdır. Bu çağırım C / C++ derleyicilerinin varsayılan çağırımıdır. Eğer C dosyalarında hernangi bir çağırım belirtilmemiş ise, bu fonksiyon cdecl olarak çağırılacaktır. Yani aşağıdaki fonksiyonlar aynı şeyi ifade edip her iksinin de çevirimi aşağıda gösterilmektedir.

void bir_proc();
__cdecl void ikinici_proc();

procedure bir_proc; cdecl;
procedure ikinci_proc; cdecl;

İleride makroları göreceğiz. Aşağıdaki makro tanımlamaları da geçerlidir ve kullanılmaktadır.

__stdcall = _stdcal = CALLBACK = WINAPI = APIENTRY = PASCAL = APIPRIVATE

__cdecl = _cdecl = WINAPIV

__fastcall = _fastcall

Yukarıda eşitliklik ile ifade edilenleri birbirlerinin aynısı olarak kabul edebilirsiniz.

DLL Kullanımı ve Çağırımlar

Normalde bir DLL’den bir fonksiyonu kullanmak için fonksiyonu nasıl tanımlayacağımızı bir hatırlayalım:

const
  DLLDosyasi = 'birkutuphane.dll';
procedure bir_proc(); cdecl; external DLLDosyasi;

Kendi DLL’imizi kullandığımızda fonksiyonu nasıl tanımlayacağımızı biliyoruz. Peki DLL’i biz yazmamış isek ne yapacağız?

Bu durumda, eğer herkes tarafından kullanılabilir bir DLL dosyası ise, DLL sağlayan firma, ekip, yazılımcı, vs. DLL dosyası ile beraber bir “header” dosyası sağlayacaktır.

Delphi’de, bildiğiniz gibi, unit iki bloktan oluşur. Birinci blok yani interface bloğu, unit tarafından “unit dışında” kullanılacak olan sınıf, değişken, fonksiyon, vs. ‘den oluşur. İkinci blok yani implementation bloğu ise, interface bloğunda tanımlanmış olan fonksiyon ve sınıfların esas kodlarından oluşur. Yani esas çalıştırılan kodlar implementation kısmında bulunur. Ayrıca implementation’da tanımlı herhangi bir değişken, fonksiyon, vs. eğer interface’de tanımlı değilse diğer unitlerde görünmezler ve kullanılamazlar.

C / C++ dosyaları da Delphi’nin unit dosya mantığının aynısıdır. Fakat Delphi’nin aksine C / C++ dosyaları tek parça halinde değil iki parça halinde tutulurlar. Delphi’de interface olarak ifade ettiğimiz blok C ‘de “header” olarak ifade edilir ve “.h” uzantısına sahiptir. Nadir de olsa C++’da header dosyaları “.hpp” uzantısı alabilirler. Delphi’de implementation olarak ifade edilen esas çalışan kodlar ise C’de “.c” ve C++’da ise “.cpp” uzantısı ile ifade edilen dosyalardadır.

Header dosyaları, şart olmasa da, genelde kütüphanenin “include” adlı klasöründe barındırılmaktadır. Kullanacağınız DLL’in header dosyası da bu veya bunun benzeri bir klasörde bulunacaktır. Header dosyası olmadan Delphi çevirimi yapmamız çok zor olacaktır. Hatta üst düzey assembler bilginiz olması gerekebilir. Bu yüzden DLL ile beraber en az bir adet header dosyasına sahip olduğunuzu varsayıyorum.

Bu başlık altında esas olarak anlatmak istediğim mevzuya şimdi geliyoruz.

DLL’e ait header dosyasına baktığımızda fonksiyonların hangi çağırım mekanizmalarını kullandıklarını görebiliyor ve anlayabiliyoruz. Fakat derlenmiş olan DLL dosyalarında bu çağırım mekanizmalarını belirten hernhangi bir işaret var mı?

Bunun için yardımcı bir araca ihtiyaç duyacağız. Aslında TDump isimli ve delphi ile beraber gelen bir konsol uygulaması bulunmakta. Ancak konsol uygulaması yerine göresel bir aracı tercih ederim. Ama illaki tdump kullanmak isteyen olursa “-b” parametresi ile beraber kullanabilirsiniz. Her neyse, ihtiyacımız olan program “Dependency Walker” . Bu program ile DLL’de bulunan tüm fonksiyonları isimleri ile beraber görebiliriz.

Peki header dosyasında fonksiyonlar ayrıntılı bir şekilde olmasına rağmen neden ekstra bir araca ihtiyaç duyuyoruz. Aslında ekstra bir programa ihtiyacımız yok. Header dosyaları fazlasıyla yeterlidir. Fakat bazen DLL’ler varsayılan ayarlarla derlenmemektedir. Bu da bize sorun çıkarabilmektedir.

DLL’ler derlenirken fonksiyon isimleri çeşitli ekler alırlar. Bu ekler, fonksiyonun hangi çağırımı kullandığını belirler. Ama bazen bu varsayılan isimlendirmenin dışına çıkan kütüphane yazılımcıları, bütün ekleri kaldırabiliyorlar. Mesela cdecl fonksiyonları önlerinde “_”  işaretini barındırırlar. Veya stdcall fonksiyonları fonksiyon isiminden sonra “@” işareti ve parametrelerin boyutlarını içeren bir dizi ekten ibarettirler. Dependency Walker gibi programlar, bize fonksiyonların hangi isimlerden oluştuğunu gösterecektir. Eğer header dosyasını Delphi’ye hatasız aktardık fakat halen fonksiyonun bulunmadığına dair hata alıyorsak demek ki isimlendirmeler yanlış demektir. Bunun için aşağıdaki yöntemi kullanmalıyız:

procedure BirProc; cdecl; external DLLDosyasi name '_bir_proc';

Gördüğünüz gibi “external” direktifinin hemen sonuna bir boşluk ile beraber bir name direktifi ekledik. Bu “name” direktifi ile DLL’deki fonksiyona direk olarak işaret etmiş oluyoruz. Bu tekniği sadece ihtiyaç dahilinde kullanabilirsiniz. Veya C / C++ ismi size hoş gelmedi ise fonksiyonun ismini Delphi’de kullanım adını değiştirmek için kullanabilirsiniz.

Not

Bir tecrübemi aktarmak istiyorum. Eğer C / C++’a fazla hakim değilseniz, muhtemelen header dosyalarını çeviriken bir çok hata yapacaksınız. Bu durumda DLL’i statik olarak kullandığınızdan dolayı, delphi programı derleyecek ama çalıştıramayacktır. Ve program donacaktır. Çünkü istediği DLL içinde sizin tanımladığınız gibi bir fonksiyon bulamamıştır. Bunun yerine ilk başlarda, header dosyasının çevirimi doğru bir şekilde çevrilene kadar, DLL dosyasını dinamik olarak yükleyin. Bu şekilde çıkan hataları, hangi fonksiyon tanımlamasından kaynaklandığını belirleyebilirsiniz. Dinamik DLL yüklemesinin nasıl yapıldığını internetten araştırarak bulabilirsiniz.

Not

Header dosyalarını çevirmek için aslında JEDI kütüphanesine ait bir araç bulunmaktadır. Fakat bu araç da tam olarak header dosyalarını çevirememektedir. Daha doğrusu yine burada anlattığımız bilgilere ihtiyaç duyacaksınız. Bu araç sadece çok büyük dosyalarda yazım kolaylığı sağlamak açısından bir kolaylık getirmektedir. Ayrıca ileride anlatacğımız konular için bu araç yetersiz kalmaktadır. Bu araca Dr. Bob’un sitesinden ya da JEDI kütüphanesinden erişebilirsiniz. (Header Conversation Tool)

Çağırım mekanizmalarına hakim olmak Delphi çevirimi noktasında size büyük kolaylık sağlayacaktır. Bu yüzden bu konuyu ilk sıraya aldım ve biraz da uzun tuttum.

Veri Tipleri

C / C++ kodları, çok fazla pointer ile ilgili işlemleri barındırmaktadır. Basit bir tip tanımlamasında bile pointerlara ihtiyaç duyarsınız. Fakat C / C++’da bulunan bu pointer kullanımı Delphi’ye geçtiğinde illaki pointer kalacak diye bir şart yoktur. Kullanımda bu olay farklılık göstermektedir.

İlk önce basit veri tiplerinden başlayalım. Aşağıdaki fonksiyona bir göz atalım:

char* birfonksiyon(void);

Burada “char*” olarak çıktı veren bir fonksiyonuz mevcut. C’de “*” işareti pointer tanımlamak ve çarpım işlemlerini yapmak için kullanılır. Eğer char, int gibi bir tip ile birlikte kullanılıyorsa bu, pointer operatörüdür. Bu örnekte “char*” ifadesi bir char işaretçisini ifade eder. Bu Delphi’de PAnsiChar ile ifade edilir. PChar demiyorum çünkü Delphi 2009 ile beraber artık PChar unicode oldu. Fakat buradaki “char” ansi olan bir char tipidir. Bunun Delphi karşılığı:

function birfonksiyon: PAnsiChar; cdecl;

olacaktır. Burada kullanılan C / C++ pointer’ı aynı şekilde Delphi’de de pointer olarak geçmiştir. Fakat bazen C’de pointer’lar hem pointer tanımlamak için, hem dizi tanımlamak için hem de parametrelerde çıkış için kullanılabiliyor. Bunların ayırımını zamanla ve tecrübeyle kazanacaksınız. Aşağıda referans olarak kullanabileceğiniz bir tablo gözükmektedir. Bu tabloyu kullandıkça artık aşina olup tekrar dönüp bakmayacağınızı da zannediyorum. Ama şimdi her birine birer birer göz atmanızda yarar var.

Tabloyu incelerseniz çoğu tipin birbirinin aynısı olduğunu anlarsınız. Bu yüzden tablo biraz uzunca oldu. Bunun nedeni C / C++’da bolca makro denilen yapıların kullanılmasıdır. Makrolar ile ilgili işlemleri ileride anlatacağımızdan şimdilik burada kısa kesiyoruz.

Gördüğünüz gibi string yerine PChar yada PAnsiChar kullanılmakta. Tabloda ayrıca Delphi 2009 ve yukarısında kullanılmak üzere verdiğim alternetifler de mevcut.

#define UINT unsigned int

Veri tipleri ile ilgili zamanı geldikçe yine değineceğiz. Ama giriş için bu kadarlık bilgi yeterli.

Makrolar

Diyeceksiniz ki, ne oluyor C dersine mi başladık? Eğer bir dilden diğer dile çevirim yapmak istiyorsanız her iki dilin de incelikleri bilmeniz gerekmektedir. Tabi biz burada bir C kitabı yazacak değiliz. Bunun yerine mümkün olduğunca kısa tutup püf noktalarını vermeye çalışıyorum. Fakat, yeri gelecek bir C kitabını karıştırmanız gerekebilecek veya C ile ilgili bir siteyi…

Makrolar C / C++ derleyicilerine, derlemeden hemen önce yapılacak olan işlemleri bildirir. Bir nevi Delphi’deki {$ ..} derleyici direktiflerine benzeselerde bunlar daha karmaşıklardır. Önemli nokta, makroların derlemeden hemen önce çalıştırılmasıdır ve derlemeye dahil olmamasıdır. Bu yüzden C / C++ derleyicileri precompile denilen bir işleme tabi tutulurlar. Bu da C / C++ derleyicilerinin neden bu kadar yavaş derlediklerinin bir sebebidir. Eğer C / C++ ile büyük bir programı derlememiş iseniz hala, Delphi gibi 1-2 sn içinde derlediğini zannedersiniz. Halbuki C/C++’da ömrünüz yarısı derlemekle geçer

Aşağıda tanımlı basit bir makro görüyorusunuz:

#define BIRMAKRO MakronunDegeri

Makro burada gördüğünüz gibi #define ile tanımlanıyor. Delphide olduğu gibi #ifdef, #ifndef, #endif gibi ifadelerle bu makronun tanımlı olup olmadığı kontrol edilebilir.

Peki bu makro delphi’ye geçirilecek mi? Belki evet belki hayır. Eğer makro bir fonksiyonu tanımlıyorsa bu durumda makroyu delphide tanımlamalısınız. Aksi taktirde makronun değeri sizin için yeterlidir. Makroyu geçrimenize gerek yok.

Eğer önceki konudaki tüyoyu okudu iseniz makroların gerçek değerlerine nasıl ulaşacağımızı biliyoruz. Mesela aşağıdaki makroyu birebir delphi’ye geçirmeye luzum yoktur:

C:

#define size_t unsigned int
__stdcall size_t getSize();

Delphi:

function getSize: Cardinal; stdcall;

Ama isterseniz size_t makrosunu bir tip olarak tanımlayabilirsiniz de:

size_t = Cardinal;

Ama lüzum yok. Peki hangi makroları delphi’ye çevirmemiz gerekli? Şimdiye kadarki tecrübeme göre genelde fonksiyon makrolarını geçrimek yeterli. Aşağıda örnek bir fonksyion makrosu mevcut ve devamında delphi kodlarını bulabilirsiniz:

#define Fonksiyon(Msg) MessageBox(NULL, Msg, NULL, NULL)

procedure Fonksiyon(Msg: PChar); inline;
begin
  MessageBox(0, Msg, '', 0);
end;

Gördüğünüz gibi sadece “inline;” olarak tanımlamamız aynı etkiyi yapacaktır. Çünkü “inline” direktifi de makro gibi fonksiyonun çağrıldığı yerde çalıştırılır. Inline ve makro fonksiyonlar için internette bir çok makale bulabilirsiniz.

Bunun dışında makrolar ile iligli olarak şunu söylemek istiyorum. Önceden de dediğim gibi her makronun bire bir Delphi’ye çevrilmesine gerek yoktur. Makro fonksiyonların haricinde bir de bazen makro sabitler de tanımlanabilir. Mesela:

#define ei_NONE 0
#define ei_WRITE 1
#define ei_READ 2
#define ei_CREATE 3

Bu tanımlamaları ister const ile tek tek eşitleyerek yaparsınız isterseniz enumerator tanımlarsınız. Biz ikisini de görelim:

//const ile
const
  ei_NONE = 0;
  ei_WRITE = 1;
  ei_READ = 2;
  ei_CREATE = 3;
//enumerator ile
type
  Tei = (ei_NONE = 0, ei_WRITE = 1, ei_READ = 2, ei_CREATE = 3);

Tercih size kalmış…

Çok karmaşık makrolar geldiğinde internetten veya bir c kitabından yardım alabilirsiniz. Fakat bu kadarlık bilgi sizi fazlasıyla idare edecektir.

Gelecek Makalede

Daha yapacağımız çok işler olacak. Şimdilik bu verdiğimiz bilgiler ile kendiniz çevirimler deneyebilirsiniz. Fakat, daha görememiz gereken çok önemli konular mevcut. Özellikle fonksiyon parametreleri başlı başına bir konu başlığı.

Bununla beraber bu makale serisinde sadece DLL kullanımını görmeyeceğiz. Gelecek makalelerde DLL kullanmadan C obje dosyalarını direk olarak delphi’ye gömeceğiz. Böylece programınızın yanında ek bir DLL verme zorunluluğunuzda kalkacak. Tabi bu konu başlı başına bir makale bölümü olacaktır.

Yine gelecek makalelerde hedear dosyaları haricindeki, implementation olarak ifade ettiğimiz kısımları da sıfırdan Delphi’ye nasıl çevrileceğinden bahsedeceğiz. Daha doğrusu yine bazı püf noktalara değineceğiz. Yoksa tüm gramerin nasıl çevrileceğini anlatmak biraz uzun ve sıkıcı olabilir.

Bu bölümlük bu kadar.

Fikir, eleştiri ve önerilerinizi bekliyorum.

Fatih Tolga Ata – 2009