SDL C kütüphanesi için yavaş da olsa ilintileri yazmaya başladım. Bu arada yanlış çevirdiğim varsa düzeltebilirseniz sevinirim.

'C :'

#define	SDL_INIT_TIMER		0x00000001

'D :'

const Uint32 SDL_INIT_TIMER       = 0x00000001;

Bir de yardımcı olarak baktığım bu sayfada (http://digitalmars.com/d/2.0/htomodule.html) şu şekilde bir örnek vermiş.
'C :'

typedef struct Foo
{   int a;
   int b;
} Foo, *pFoo, *lpFoo;

'D :'

struct Foo
{   int a;
   int b;
}
alias Foo* pFoo, lpFoo;

Benim çevirmek istediğim örnek bu şekilde:
'C :'

typedef struct Foo
{

}Foo;

O zaman bu şekilde mi çevirilecek acaba:
'D :'

struct Foo
{
}

Bir de asıl anlamadığım içiçe geçmiş iki tane yapı var. Ve bunlardan içteki yapının parantezleri yok.
'C :'

typedef struct SDL_Surface {

	struct private_hwdata *hwdata;
} SDL_Surface;

Bu arada D öğrenmenin şöyle faydaları da var : C kültürümüz artıyor :-D

C++ kullanırken 1 gram C bilmeye gerek yoktu.

Bu arada ilk denemem başarılı bir şekilde çalıştı :)

import std.stdio;

alias uint Uint32;


extern(C)
{

   int SDL_Init(Uint32 flags);
   void SDL_Quit();
}

int main(string[] args)
{
   SDL_Init(SDL_INIT_EVERYTHING);
   writeln("Sdl ilklendirildi");

   SDL_Quit();

   return 0;
}

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (erdem):

> const Uint32 SDL_INIT_TIMER       = 0x00000001;
> ```


Olur ama daha da uygunu immutable olur:

immutable Uint32 SDL_INIT_TIMER = 0x00000001;

Ve daha daha uygunu da enum:

enum Uint32 SDL_INIT_TIMER = 0x00000001;

enum'un bu anlamda kullanımı C'de ve C++'ta yok. *Derleme zamanında bilinmesi gereken hazır değer* anlamını taşıyor.

Alıntı:
>

Ben öyle kısaca yazılmasını hiçbir zaman anlamamışımdır. Şöyle daha açık:

struct Foo
{ int a;
int b;
};

typedef struct Foo Foo;
typedef struct Foo* pFoo;
typedef struct Foo* lpFoo;

Tabii aslında önceki typedef'lerden yararlandıkça:

typedef struct Foo Foo;
typedef Foo* pFoo;
typedef pFoo lpFoo;

Alıntı:
>
> 'D :'

Doğru. Ama işte son iki alias ayrılabilir de:

alias Foo* pFoo;
alias pFoo lpFoo;

Alıntı:

> typedef struct Foo
> {
>
> }Foo;
>

> struct Foo
> {
> }
> ```


Evet, bu typedef numarası yalnızca C'de gerekiyor.

Alıntı:
>
> Bir de asıl anlamadığım içiçe geçmiş iki tane yapı var. Ve bunlardan içteki yapının parantezleri yok.
> 'C :'

Onlar iç içe yapı değil. private_hwdata'ya ya typedef numaraları daha önce uygulanmamış; ya da uygulanmışsa bile uzuncu yazmışlar. hwdata bir üye ve türü 'private_hwdata yapısı göstergesi.'

Daha önce private_hwdata diye bir yapı tanımlanmışsa şöyle de yazılabilir:

// Daha once tanimlanmis olsun:
struct private_hwdata
{};

// Kisa ismi:
typedef struct private_hwdata private_hwdata;

// Simdi soyle olur:
typedef struct SDL_Surface {

private_hwdata *hwdata;

} SDL_Surface;

Alıntı:
> Bu arada ilk denemem başarılı bir şekilde çalıştı :)

Harika! :)

Ali

-- 
[ Bu gönderi, <http://ddili.org/forum>'dan dönüştürülmüştür. ]

Bu arada curl'nin ilintisi Phobosa eklendi. https://github.com/D-Programming-Language/phobos/blob/master/etc/c/curl.d

Orada htod ile çevrilip düzeltildiği yazıyor. D2 içinde uyum sağlatabiliriz

Ayrıca D2'ye ilinti yazmak için örnek proje: https://github.com/tbolsh/mysql-wrapping-for-D-programming-language-v2

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Bağlantılar için teşekkürler. Kodun son durumu şu şekilde:

http://paste.pocoo.org/show/386530/

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Gene burda makrolarla değişik bir yapı tanımlamışlar.

'C :'

typedef struct SDL_RWops {
   // ...
	Uint32 type;
	union {
#if defined(__WIN32__) && !defined(__SYMBIAN32__)
	    struct {
		int   append;
		void *h;
		struct {
		    void *data;
		    int size;
		    int left;
		} buffer;
	    } win32io;
#endif
#ifdef HAVE_STDIO_H
	    struct {
		int autoclose;
	 	FILE *fp;
	    } stdio;
#endif
	    struct {
		Uint8 *base;
	 	Uint8 *here;
		Uint8 *stop;
	    } mem;
	    struct {
		void *data1;
	    } unknown;
	} hidden;

} SDL_RWops;

Ben windows kullanmadığım için bu makro kısmını attım :) Ama aslında her iki platformda çalışması için sanırım o kısmı kesmemek lazım. Bir de böyle makro kullanmasındaki espriyi anlayamadım.

Ayrıca 'std.c.stdio' olduğu için ve 'FILE' tanımlı olduğu için o kısmı da yorum haline getirmedim.
'D :'

struct SDL_RWops
{
   // ...
   Uint32 type;
   union
   {
       struct
       {
           int autoclose;
           FILE * fp;
       }
       struct
       {
           Uint8 * base;
           Uint8 * here;
           Uint8 * stop;
       }
       struct
       {
           void * data1;
       }
   }
}

'C :'

#define SDL_LoadBMP(file)	SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)
extern DECLSPEC SDL_Surface * SDLCALL SDL_LoadBMP_RW(SDL_RWops *src, int freesrc);
extern DECLSPEC SDL_RWops * SDLCALL SDL_RWFromFile(const char *file, const char *mode);

'D :'

extern(C)
{
   SDL_Surface * SDL_LoadBMP (const char * file)
   {
       return SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1);
   }

   SDL_Surface * SDL_LoadBMP_RW(SDL_RWops * src, int freesrc);
   SDL_RWops * SDL_RWFromFile(const char * file, const char * mode);
}

Gene aynı şekilde 'SDL_LoadBMP' işlevini makro olarak tanımlamışlar. 'alias' olarak tanımlayabilirmiydik bilmiyorum.

Bu da çalıştı :) Ve ilginç bir şekilde daha önce örneğin şu şekilde SDL_LoadBMP işlevini çağırdığımızda bir hata verirken:

   merhaba = SDL_LoadBMP("merhaba.bmp");

Alıntı:

Bu sefer vermedi. Demek ki derleyici 'string' ile 'const char*' arasındaki tür dönüşümünü yapabiliyor. Ya da ben öyle anladım.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (acehreli):

> >         struct
> >         {
> >             int autoclose;
> >             FILE * fp;
> >         }
> > ```

>

O zaman bu şekilde bir isim vermek daha doğru mu olurdu acaba.

   struct stdio
   {
       int autoclose;
       FILE * fp;
   }

Örneğin bu ikisi de C yapısı olsun.

   struct foo
   {
       int a;
       int b;
   }

   struct
   {
       int a;
       int b;
   } foo;

Bunlar aynı mı olmuş oluyor. Bir de benim elimin altında online bir C kitabı olsa çok iyi olacak galiba :) Ben bakıyorum arıyorum ama bu kadar ayrıntılı anlatan bir kaynak bulamadım.

Yardımlar için çok teşekkürler! :)

Bu arada kodun en son hali şu şekilde :

http://paste.pocoo.org/show/388108/

-- 
[ Bu gönderi, <http://ddili.org/forum>'dan dönüştürülmüştür. ]

Alıntı (erdem):

Bunun yerine başka başlık dosyaları eklemek daha iyi bir yöntemdir. Kod içindeki işlevlerde de #ifdef'ler kullanmışlarsa dertlidir.

Alıntı:

Hem de yapıya stdio diye isim vermen de gerekmemiş:

Alıntı:

>         struct
>         {
>             int autoclose;
>             FILE * fp;
>         }
> ```


Alıntı:
> Gene aynı şekilde 'SDL_LoadBMP' işlevini makro olarak tanımlamışlar. 'alias' olarak tanımlayabilirmiydik bilmiyorum.

Senin yaptığın gibi, olabiliyorsa işlev olmalı zaten.

Alıntı:
> Demek ki derleyici 'string' ile 'const char*' arasındaki tür dönüşümünü yapabiliyor

Evet, bunu geçen gün konuştuk: toStringz'yi çağırmak gerekmiyor; D bunu otomatik olarak ve doğru şekilde yapıyor.

Ali

-- 
[ Bu gönderi, <http://ddili.org/forum>'dan dönüştürülmüştür. ]

Alıntı (erdem):

>         struct stdio
>         {
>             int autoclose;
>             FILE * fp;
>         }
> ```


Eğer o yapı türünün ismi (stdio) daha sonradan programda kullanılmayacaksa yazmak gerekmez. O yüzden daha doğru olduğunu söyleyemeyiz.

Ama dikkat edersen SDL kodundaki stdio üye ismiydi. O gösterdiğin kodda ise stdio tür ismi olmuş. (Aşağıdaki sorudaki fark.)

Alıntı:
>
> Örneğin bu ikisi de C yapısı olsun.
>

    struct foo
    {
        int a;
        int b;
    }

O foo isminde bir tür tanımlıyor. Daha sonradan o türden çok sayıda değişken oluşturabiliriz.

Alıntı:

>         struct
>         {
>             int a;
>             int b;
>         } foo;
> ```


O, tür ismi belirtilmemiş olan bir yapının foo ismindeki tek değişkenini tanımlıyor.

'Anonymous union' ve 'anonymous struct' konularına bakabilirsin. D'de de var:

import std.stdio;

struct Değer
{
union // isimsiz birlik (anonymous union)
{
uint hepsi;

   struct                   // isimsiz yapı (anonymous struct)
   {
       ubyte[4] baytları;
   }

}
}

void main()
{
auto değer = Değer(0x01020304);
writeln(değer.hepsi); // 'hepsi' diye üyesi varmış gibi
writeln(değer.baytları[0]); // 'baytları' diye üyesi varmış gibi
}

Dikkatli bakılırsa aslında Değer'in ne hepsi diye, ne de baytları diye üyeleri var. Değer'in içinde isimsiz bir birlik tanımlı. Onun içinde de isimsiz bir yapı. İsimsiz birliklerin ve yapıların üyeleri dışarıdaki türün üyeleri haline gelirler.

Ali

-- 
[ Bu gönderi, <http://ddili.org/forum>'dan dönüştürülmüştür. ]

C onaltılık sabitleri nasıl yorumluyor acaba. İşaretli olarak mı işaretsiz olarak mı ? (örneğin '0x23FE') gibi bir değerimiz olsun.

Ben daha önceki konuştuklarımızdan işaretsiz olabilir diye düşündüm ama tam emin olamadım.

Bunu sormamın nedeni SDL yanında OPENGL kütüphanesi için de ilinti yazmaya başladım :)

'C :'

#define GL_ALL_ATTRIB_BITS		  0x000FFFFF
#define GL_MODELVIEW				0x1700
#define GL_NO_ERROR 				0x0

'D :'

enum uint   GL_ALL_ATTRIB_BITS = 0x000FFFFF;
enum ushort GL_MODELVIEW       = 0x1700;
enum ubyte  GL_NO_ERROR        = 0x0;

İlkönce yukardakilerin hepsinin yerine basitçe 'uint' yazmayı düşündüm. Ama örneğin en baştaki 4 bayt, diğeri 2 bayt alttaki 4 bit. Bu yüzden yukarıdaki gibi yaptım.

En değişiği de alttaki. Anladığım kadarıyla 4 bit ama onun karşılığı olarak örneğin bool kullansak olur muydu bilmiyorum.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Teşekkürler. Görünüşe göre bu değerler 'typeof(değer).stringof ' şeklinde yazdırılınca D ile hep 'int' yazdırılıyor.

Ama C ile bu değerlerin karşılıklarına baktığımda, D karşılıklarının fazlasıyla bu değerleri tutabildiğini gördüm.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]