Dinamik Kütüphaneler ile Derlemek

[Tagli]

Evet, bir başka garip ve belki de acemice Linux sorusuyla karşınızdayım...

Az önce nCurses denemeleriyle uğraşırken farkettim: Derlemeyi şu şekilde yapınca sorun yok:

gcc test.c -lncurses -o test

Ama, argümanların yerini değiştirince linker hata veriyor. Yani komutu böyle yazarsam:

gcc -lncurses -o test test.c

Bir yığın hata ile karşılaşıyorum. Sanki -lncurses ifadesini hiç yazmamışım gibi.

Gözümden kaçan nedir? Acaba kaynak dosyaları (.c) her zaman kütüphanelerden önce mi gelmeli?

[fatihinanc]

Evet hocam öyle olmalı. Önce derlenecek .c dosyası yazılmalı ve arkasından derleme parametreleri eklenmeli.
gcc nin yardım kısmında da çıkıyor olması gerekiyor bu parametre sıralamasının...

[Erdem]

Aslında make kullanımı işleri daha da kolaylaştırır:

CXX=g++ -O2
CXXFLAGS=`sdl-config --cflags`
OBJS=ana.o
LDFLAGS=-lGL -lGLU -lSDL_image `sdl-config --libs`

ana:    $(OBJS)
                $(CXX) $(OBJS) $(CXXFLAGS) $(LDFLAGS) -o ana

Bunun dışında nm program kodlarının hangi sembolleri kullandıklarını gösterir. Örneğin önceden yazmış olduğum deneme programı üzerinde çağırıp 'Fc' içerenleri süzersek:

$ nm deneme | grep Fc
         U FcCharSetCreate
         U FcCharSetDestroy

Satır başlarında U, "use"dan geliyor ve deneme'nin o işlevleri kullandığını söylüyor.

ldd de dinamik kütüphane bağımlılıklarını gösterir.

$ ldd deneme
linux-gate.so.1 =>  (0xf7742000)
libfontconfig.so.1 => /usr/lib32/libfontconfig.so.1 (0xf76f6000)
librt.so.1 => /lib32/librt.so.1 (0xf76ed000)
libpthread.so.0 => /lib32/libpthread.so.0 (0xf76d3000)
libm.so.6 => /lib32/libm.so.6 (0xf76ad000)
libc.so.6 => /lib32/libc.so.6 (0xf7552000)
/lib/ld-linux.so.2 (0xf7743000)
libfreetype.so.6 => /usr/lib32/libfreetype.so.6 (0xf74db000)
libz.so.1 => /usr/lib32/libz.so.1 (0xf74c6000)
libexpat.so.1 => /lib32/libexpat.so.1 (0xf749f000)

deneme'nin hangi kütüphanelere bağımlı olduğunu görüyoruz.

Editör olarak tavsiyem de tabi ki  _emacs

[Tagli]

make aracının kullanımı, öğrenmek istediğim ama hep gözümde büyüdüğü için cesaret edemediğim bir konu. Temel mantığını ve nasıl çalıştığını biliyorum, ama oturup da sıfırdan makefile yazacak kavrayışa erişemedim henüz. Gözümün korkmasında, autoconf vs. gibi sistemler tarafından üretilen 10000 satırlık makefile'lar görmemin de etkisi var tabi.

Zaten kafamda şekillendirmekte en zorlandığım konu, bir yazılım projesinin dosyalara ve klasörlere ne şekilde ayrılması gerektiği ve nasıl sistematik bir şekilde derlenmesi gerektiğidir. Bununla ilgili olarak kavramakta zorlandığım bir diğer konu da versiyon kontrol sistemleridir. Hepsinin genel mantığını biliyorum, ama "Hadi kullan" desen kullanamam.

Editör konusuna gelince, busybox içinde kırpılmış da olsa bir kopyası bulunması sebebiyle vim bana daha çekici geliyor. Ancak henüz kendisini öğrenmek için zaman ayıramadığımdan (kullanımı sıkıcı ve yavaş olan çok temel komutları biliyorum sadece) şimdilik gedit ile idare ediyorum.

[vsalma]

Versiyon kontrol sistemleri ile alakalı bir yorumum olacak.

Versiyon kontrol sistemlerini bir projede çok aktif bir şekilde(pek çok kullanıcı, bir repoda pek çok proje, pek çok ortak dizin) kullanmadan tam olarak öğrenilmiyor diye düşünüyorum. svn i eski şirketimde ve arkadaşlarımla yaptığım kişisel projelerde kullandım ama şimdi büyük projede kullanınca eskiden hiç bilmediğimi düşünüyorum. Şu an kişisel olarak git kullanıyorum ama hakkını veremiyorum çünkü çoğu şeye ihtiyacım olmuyor.

Versiyon kontrol sistemleri için open source bir projeye destek verirseniz kullanımınız gelişebilir. Daha iyi bir bilen varsa çevrenizde takıldığınız kısımda onun yardımları gelişimi hızlandırabilir.

[Erdem]

Aslında ben de ilk başladığımda aynen sizin gibi düşünüyordum 

Biraz Emacs kullanmayı öğrenmiştim, sonra aslında lisanslı olarak Visual Studio kullanmama rağmen baktım Emacs ile çok daha rahat ediyorum Gentoo'ya taşındım. Aynen make kullanımı ve sürüm kontrol sistemleri çok karışık gelmişti.

Aslında make kullanımı gerçekten kolay sadece bir kaç deneme yapmak gerekiyor. Burada daha önce Cdili grubunda konuşulmuş make kullanımı ile ilgili bir mesajı paylaşmak istiyorum.

Alıntı :

Aşağıda bunları anlatırken, komut satırında yazacağımız satırların başına $ işareti koydum...

Adımlar
=======

1) Kaynak kod, uzantısı c olan bir kütük olarak yazılır (örneğin deneme.c):

#include <stdio.h>
int main()
{
    printf("Merhaba Linux!\n");
    return 0;
}

2) Kaynak kod derlenir ve program parçası (deneme.o) oluşturulur:

$ gcc -c deneme.c

Herşey yolunda gittiyse, deneme.o adında bir kütük oluşmuştur:

$ ls -l deneme.o

Çıktısı şunun gibi olabilir:

-rw-rw-r-- 1 <kullanıcı> <grup> 904 Feb 23 10:31 deneme.o

3) Derleyicinin üstü örtülü olarak bağlayıcıyı çağırması sağlanarak program bağlanır (programın adının 'deneme' olmasını istediğimizi düşünelim):

$ gcc deneme.o -o deneme

4) Çalıştırılır:

$ ./deneme

Herşey yolunda gittiyse şöyle bir çıktı almamız gerekir:

Merhaba Linux!

Notlar
======

1) İkinci ve üçüncü adımlar genellikle birleştirilirler:

$ gcc deneme.c -o deneme

Ara adım olan deneme.o adlı program parçası, ancak eğer gerekiyorsa oluşturulur. deneme.o adlı kütük bu işlemden önce zaten dizinde bulunuyorsa, varlığına devam eder. Eğer dizinde yoksa, otomatik olarak oluşturulur, bağlama işleminde kullanılır ve yine otomatik olarak silinir.

2) Derleyicinin bizi kodumuzda bulunan şüpheli kullanımlar konusunda uyarmasını sağlamak için bol bol uyarı seçeneği kullanılır. Örneğin:

$ gcc -g -Wall -W -ansı deneme.c -o deneme

Başka bir sürü seçenek de kullanılabilir; şimdilik bu kadarı yetsin

Ayrıca not: -g seçeneği, programın içine hata ayıklayıcı (örneğin gdb) tarafından kullanılacak bilgiler gömmek için kullanılır.

3) Bütün bu adımları otomatikleştirmek için Makefile adında bir kütük yazılır. 'make' adlı araç program da o Makefile'a bakarak programı nasıl oluşturması gerektiğini bilir.

3a) Projenin bulunduğu dizine (deneme.c'nin bulunduğu yere) Makefile adında bir kütük oluşturun. İçinde şunlar bulunsun:

DERLEYİCİ_AYARLARI = -g -Wall -W -ansı

KAYNAKLAR=deneme.c

deneme: $(KAYNAKLAR)
gcc $(DERLEYİCİ_AYARLARI) $(KAYNAKLAR) -o $@

3b) Programı oluşturmak istediğinizde artık yalnızca 'make' yazın:

$ make

make çok akıllı bir programdır. Makefile adlı kütüğü okur; eğer
derlemeye gerek yoksa (deneme.c'nin değişiklik tarihi deneme'den daha
yeni değilse); hiçbir şey yapmaz ve programı oluşturmanın
gerekmediğini bildirir:

make: `deneme' is up to date.

deneme.c'de herhangi bir değişiklik yapıp kaydettikten sonra tekrar 'make' yazarsak, programın tekrar oluşturulması gerektiğini anlar ve yeniden derler (program dolaylı olarak bağlanır da).

make programını ve Makefile'i çok kısa anlattım; olanakları bu mektubun konusunu aşar... Onun için şimdilik o verdiğim küçük Makefile ile yetinin.

Alıntı sonu

Bir de make'in güzel bir özelliği bir kere kullanımını öğrendikten sonra artık istediğiniz dil için make dosyası hazırlayabiliyorsunuz. Yani dile bağlı değil. Örneğin bu make dosyalarını D için hazırlamıştım ama ufak değişikliklerle istediğiniz dilde kullanabilirsiniz.

Sürüm kontrol sistemi olarak ben de github kullanıyorum. Kullanımını da gayet güzel anlatmışlar. Bir kaç kere deneyince çok kolay kullanıldığını ve çok hoş özellikleri olduğunu görüyorsunuz.

https://help.github.com/articles/set-up-git#platform-all

[fatihinanc]

@Erdem hocam gerçekten güzel bir anlatım olmuş, sağ olun.

Benim de bir ara makefile dosyaları ile işim olmuştu. STM32F4 için komut satırında derleme ve programlama yapmam gerekiyordu.
O işle uğraşırken makefile ları okuya okuya baya alışmıştım. Biraz alışınca bütün o FLAG ları vs. anlayabiliyorsunuz. Kendine özgü küçük bir dil içeriyor aslında makefile dosyaları.

Fakat şu aşamada sıfırdan makefile yazmak aslında çok gerekmiyor. Çünkü Eclipse tabanlı IDE'lerde doğrduan makefile projesi oluşturabiliyorsunuz. Ve o sizin için gerekli olan makefile ı otomatik üretiyor. Sonra da komut satırında make all make clean gibi işlemleri çok kolay bir şekilde hatasız yapabiliyorsunuz. Bütün PATH ler vs. hepsi makefile da tanımlı oluyor zaten.

Fakat emacs'te durum nasıl bilemiyorum. Bir geliştirme ortamı olmadığı için böyle bir özellik yoktur muhtemelen. Fakat dediğim gibi Eclipse tabanlı IDE ler işi oldukça kolaylaştırıyor.

Bu arada vi editörünü 2.sınıfta staj yaptığım yerde kullanmıştım. Ama bu kadar alışılması zor bir editör görmedim. Bazıları vi da işlerin çok hızlı yapıldığından bahsediyor ama ben...
Gerçi her editörün kendine göre kısayolları var ama vi alışılması en zor olan diyebilirim.

[Tagli]

Bu karikatürü muhtemelen görmüşsünüzdür ama yine de paylaşayım dedim:

[Erdem]

Ben Eclipse'i bir süre genelde Linux kurulu olmayan bilgisayarlarda kullandım. Lisanslı olarak Visual Studio kullanıyordum önceleri..

Hatta sanırım "C++ In Action Industrial Strength Programming" diye bir kitabın windows uygulamalarını yaparken karar vermiştim. Şimdi yok hInstance bilmen ne satırlarca değişken isimleri var. Ama Emacs'ın otomatik tamamlama M-/ ile Win32API programlama gerçekten çok kolay olmuştu. Hatta daha sonraları php, html'de bile çok hızlı kod yazılabildiğini söyleyebilirim. Sadece html için sonradan çıkan zencoding eklentisi ile Emacs'tan daha hızlı kod yazılabiliyor.

Son çıkan geliştirme ortamlarından Netbeans'i beğendiğimi söyleyebilirim. İçerisinde ufak bir Emacs bulunduruyor. Şöyle ki Emacs'la alıştığınız kısayolları Netbeans ile de kullanabiliyorsunuz. Yalnız D için bir eklentisi yoktu. Yakın zamanda baktığımda bir eklenti yazmışlar ama Windows 7'de çalışmadı.

Hiç automake kullanmadım. Ancak Emacs'la derlemeyi C-C ve C-C tuşlarına iki defa basarak yapıyorsunuz. Ben bunları Ctrl- Enter tuşlarına bağladım. Visual Studio'da F9 tuşu neredeydi diye aramak yerine saniyesinde kodu derleyebiliyorum. Derleme penceresinde de ya make geliyor ya da daha önce yazdığınız derleme komutu geliyor. Sanırım make dosyaları ile örneğin bir dizin içine hangi dosyayı eklerseniz ekleyin sadece make diyerek dizindeki tüm dosyaları derleyecek şekilde derleme olanağı mevcuttu. Ama ben şahsen eğer deneme amaçlı kod yazıyorsam make kullanmadan derliyorum. Eğer çok kütükten oluşuyorsa zaten proje bir plan içerisinde ilerlediği için make kullanıyorum.

Bir de Emacs ve make dosyalarının esnekliğini kullanarak örneğin PICKIT2 ile PICC ve Assembly dosyalarını çok kolay bir şekilde oluşturup denetleyici üzerinde test edebiliyorum. Örneğin MPLAB X çok hantal bir geliştirme ortamı. Zaten benim kullandığım linux sürümünde bazı hatalar, takılmalar vardı. Ama Emacs'la tek tuşla programı mikro denetleyiciye yükleyip, test edebiliyorsunuz.