# Installera &kdevelop;

I det här kapitlet beskriver vi alla steg som behövs för att kompilera och installera den integrerade utvecklingsmiljön &kdevelop;:

- Hur man skaffar &kdevelop; koncentrerar sig på hur man laddar ner den senaste källkoden för &kdevelop; från CVS.

- Krav för &kdevelop; listar programmen och biblioteken som du måste ha installerade för att kompilera den integrerade utvecklingsmiljön med lyckat resultat.

- Kompilering och installation av &kdevelop; leder dig igenom alla steg för kompilering och installation av programmet.

- Hur man skaffar dokumentation av programmeringsgränssnittet för &kdevelop; talar om vad ett programmeringsgränssnitt är och hur du skaffar ett så användbart verktyg för navigering i källkoden för &kdevelop;.

## Hur man skaffar &kdevelop;

&kdevelop; är tillgänglig i binärform från många olika &Linux;-distributioner som SuSE, RedHat med flera. Binärfilerna är paketerade på något bekvämt sätt, oftast RPM, för att enkelt kunna installeras. Följ standardinstruktionerna som ges i distributionen för att installera.

Du kan mycket väl skaffa källkoden för &kdevelop;, kompilera och installera den själv. Källkoden hittas via projektets hemsida på http://www.kdevelop.org eller via &kde;:s FTP-plats.

### Hämta dagsfärska versioner av &kdevelop; från &CVS;

Om du vill vara en del av den nuvarande utvecklingen, är versioner via anonym &CVS; från arkivet också tillgängliga. Modulnamnet är kdevelop på `:pserver:anonymous@anoncvs.kde.org:/home/kde`.

#### Ursprunglig utcheckning från &CVS;

För att skaffa en ursprunglig version av &kdevelop; måste du ladda ner den från anonym &CVS;. Följ bara stegen nedan för den här så kallade utcheckningsåtgärden.

Vi antar att du vill placera din kopia av &kdevelop; i underkatalogen `kde3src` i din hemkatalog (`~`).

- # Skapa målkatalogen, om det behövs:
- `~>` `mkdir kde3src`
- `~>` `cd kde3src`
- `~/kde3src>` `cvs -z3 -d :pserver:anonymous@anoncvs.kde.org:/home/kde co kdevelop`
- `~/kde3src>` `cd kdevelop`

När du väl har lyckats checka ut din version av &kdevelop;, kan du hänga med i ändringarna genom att använda uppdateringsproceduren som visas i nästa avsnitt.

Håll serverns last nere. Var vänlig att inte checka ut varje gång du vill få en aktuell version av &kdevelop;! Använd CVS update för detta syfte.

Nu kan du kompilera din version av &kdevelop; som visas i avsnittet Kompilering och installation av &kdevelop;.

#### Hålla din kopia av&CVS; aktuell

Efter du checkat ut &kdevelop; från CVS som visas ovan (och kompilerat med lyckat resultat), vill du hålla den aktuell för att få med alla programfixar. Följ då stegen nedan. (Återigen antar vi att du har placerat din kopia av &kdevelop; i katalogen `kde3src`.)

Observera kommandot `up` (= update) istället för `co` (vilket betyder checkout).

- `~>` `cd kde3src`
- `~/kde3src>` `cvs -z3 -d :pserver:anonymous@anoncvs.kde.org:/home/kde up kdevelop`
- `~/kde3src>` `cd kdevelop`

Håll ett öga på meddelanden som &CVS; visar under uppdateringssekvensen. De exakta stegen i kompileringssekvensen beror på dem.

Nu kan du kompilera en ny version av &kdevelop; som visas i kapitlet Särskilda hänsyn vid kompilering från &CVS;.

## Krav för &kdevelop;

För att kompilera och använda &kdevelop; med lyckat resultat, behöver du följande program och bibliotek. De är tillgängliga på de flesta plattformar som distributionspaket, och kan därigenom lätt installeras.

## Krävs

- gcc/g++ 2.95.3 eller senare (eller motsvarande)

  Tillgänglig från gcc.gnu.org

- &GNU; make (eller motsvarande)

  Tillgänglig från www.gnu.org/software/make

- &perl; 5.004 (eller senare)

  Tillgänglig från www.perl.com

- autoconf ≥ 2.52 (eller senare)

  Tillgänglig från www.gnu.org/software/autoconf

- automake ≥ 1.6 (eller senare)

  Tillgänglig från www.gnu.org/software/automake

- flex 2.5.4 (eller senare)

  Tillgänglig från www.gnu.org/software/flex

- &Qt; ≥ 3.0.3 (eller senare)

  Tillgänglig från www.trolltech.com/products/qt

- KDE ≥ 3.0.2 (eller senare)

  Tillgänglig från www.kde.org

## Valfritt:

- Verktyget ctags för källkodsnavigering, från http://ctags.sourceforge.net, som ger dig snabb åtkomst till deklarationer och definitioner med några få enkla klick på ett namn i editorn.

- Kompilatorn dot för grafikspråk, från http:/www.graphviz.org. Verktyget behövs tillsammans med &doxygen; nedan, om du vill visa klassförhållanden grafiskt (vilket starkt rekommenderas).

- Dokumentationsverktyget &doxygen;, från http://www.doxygen.org, om du vill skapa koncis och kraftfull dokumentation av programmeringsgränssnittet för dina projekt.

- Valgrind från http://developer.kde.org/~sewardj/ hjälper dig att hitta minneshanteringsproblem i dina program.

- CVS från http://www.cvshome.org, om du vill använda versionshanteringssystemet &CVS;.

- Eventuellt andra kompilatorer och/eller verktyg om du vill utveckla för ett annat språk eller plattform än C++/&kde;, eller använda någon annan specialfunktion.

1. Du kan i viss utsträckning kringgå behovet av &autoconf; ≥ 2.52 och &automake; ≥ 1.6. Ta bara bort katalogen `admin` i installationskatalogen för &kdevelop;, och skriv:

   - `(din kdevelop-katalog)>` `ln -s $KDEDIR/share/apps/kdelibs/admin admin`

   i terminalen. Det gör att &kdevelop; använder standardinställningarna i &kde;:s `admin`-katalog istället.

2. Var försiktig så att du inte blandar olika versioner av &Qt;. Länka alltid &kdevelop; med samma version av &Qt; som &kde;-biblioteket kompilerades med. Annars råkar du troligen ut för mycket konstigt beteende.

## Kompilering och installation av &kdevelop;

När alla krav väl är uppfyllda är du redo att kompilera och installera &kdevelop;. Det här kapitlet beskriver nödvändiga steg för att göra det.

- Förberedande steg berättar hur du ställer in en riktig miljö.

- Kompilera &kdevelop; handlar om hur källkoden för &kdevelop; skaffas från &cvs;, hur den förbereds för installationsprocessen, och visar till sist stegen som är nödvändiga för att kompilera och installera &kdevelop;.

- Hur man kompilerar på FreeBSD beskriver särskilda hänsyn angående Berkeley databassystemet för att kompilera och installera &kdevelop;.

- Några anmärkningar om väljare till configure talar om hur man kör &kdevelop; om det har installerats på en annan plats än i &kde;-katalogen.

### Förberedande steg

Innan du påbörjar kompileringssekvensen, måste du försäkra dig om att alla bibliotek och verktyg är tillgängliga för byggsystemet. För att uppnå detta, måste vissa miljövariabler ställas in riktigt. Stegen som ska utföras beror på vilket skal du använder i terminalen.

För att undvika att skriva in alla satserna som ställer in nödvändiga miljövariabler varje gång du vill kompilera, kan du placera dem i filen `.bashrc` eller `.cshrc`. På så sätt ställs miljövariablerna in riktigt varje gång du startar skalet.

#### Ställa in miljön för bash-skalet

Om du använder bash-skalet, lägg till följande rader:

- `export KDEDIR=`(sökväg till KDE-installationen)
- `export QTDIR=`(sökväg till Qt-biblioteket)
- `export LD_LIBRARY_PATH=$QTDIR/lib:$KDEDIR/lib:$LD_LIBRARY_PATH`
- `export LIBRARY_PATH=$QTDIR/lib:$KDEDIR/lib:$LIBRARY_PATH`
- `export PATH=$QTDIR/bin:$KDEDIR/bin:$PATH`

#### Ställa in miljön för tcsh-skalet

Om du använder tcsh-skalet, lägg till följande rader:

- `setenv KDEDIR` (sökväg till KDE-installationen)
- `setenv QTDIR` (sökväg till Qt-biblioteket)
- `setenv LD_LIBRARY_PATH=$QTDIR/lib:$KDEDIR/lib:$LD_LIBRARY_PATH`
- `setenv LIBRARY_PATH $QTDIR/lib:$KDEDIR/lib:$LIBRARY_PATH`
- `setenv PATH $QTDIR/bin:$KDEDIR/bin:$PATH`

### Kompilera &kdevelop;

I följande beskrivning antar vi att du har placerat källkoden för &kdevelop; i katalogen `~/kde3src/kdevelop`.

#### Särskilda hänsyn vid kompilering från &CVS;

Om du använder en aktuell version av &kdevelop; från &CVS;, beror de första kompileringsstegen på om du just gjort en fullständig utcheckning, eller bara uppdaterat källkoden.

#### Efter en utcheckning från CVS

Du måste initiera byggsystemet efter en ny utcheckning. Samma sak gäller varje gång du måste starta om från början. Skriv:

- `~/kde3src/kdevelop>` `make -f admin/Makefile.common cvs-clean`

och därefter alla följande steg.

Du kan behöva komma åt&CVS;-arkivet för att rensa det om några skadade eller saknade filer måste återskapas.

Kommandot `cvs-clean` tar bort alla filer som inte finns i &CVS; från katalogen. Försäkra dig om att säkerhetskopiera viktig information innan du använder det här rensningskommandot.

#### Efter en uppdatering från CVS

Nästa steg beror på utmatningen från &CVS;-uppdateringssekvensen. Om du fick något som liknar följande (observera markören U till vänster):

    U /någon_sökväg/Makefile.am

eller om du precis gjort en fullständig utcheckning, måste du skriva:

- `~/kde3src/kdevelop>` `make -f Makefile.cvs`

innan du fortsätter med alla följande steg.

#### Grundläggande kommandosekvens med `make`

När det grundläggande byggsystemet har ställts in, måste du bestämma dig för vilken typ av &kdevelop;-system du vill använda. Det görs med följande konfigureringssteg, som bygger de verkliga filerna med namn `Makefile`, som kommandot `make` kommer att använda.

Du kan utelämna väljaren `--prefix` i följande kommandorader med `configure`, om du vill att &kdevelop; ska installeras i &kde;:s standardkatalog. Se kapitlet Några anmärkningar om väljare till configure om detta.

#### En version kompilerad för avlusning

Om du vill hålla ordning på vad programmet &kdevelop; gör när det kör, kan du bygga en version kompilerad med avlusning. Tala bara om för `configure` att göra det:

- `~/kde3src/kdevelop>` `./configure --enable-debug=full --prefix=`(där din kde3 finns)

#### En version kompilerad för distribution

Om du bara vill använda &kdevelop; som det är (mindre och snabbare), räcker det med en version kompilerad för distribution. Det är förvalt i `configure`.

- `~/kde3src/kdevelop>` `./configure --prefix=`(där din kde3 finns)

Om du vill skapa din egen dokumentation av programmeringsgränssnittet för &kdevelop;, måste du ta med ytterligare en väljare i kommandot `configure`:

- `~/kde3src/kdevelop>` `./configure --`(väljare enlikt ovan) `\`
- `--with-kdelibsdoxy-dir=$KDEDIR/share/doc/HTML/en/kdelibs-apidocs`

#### Bygga och installera &kdevelop;

Kommandot `configure` kontrollerar systemet och skapar några filer vid namn `Makefile` enligt vad det hittar. Kommandot `make` använder normalt den huvudsakliga filen `Makefile`. Alltså är

- `~/kde3src/kdevelop>` `make`

tillräckligt. Om nödvändigt, skaffa rättigheter som systemadministratör genom att använda kommandot

- `~/kde3src/kdevelop>` `su`

och ange systemadministratörens lösenord. Installera sedan programmet:

- `~/kde3src/kdevelop>` `make install`

Det är allt. Om du installerade &kdevelop; i &kde;:s standardkatalog, kan du nu köra den integrerade utvecklingsmiljön. Annars är några ytterligare steg nödvändiga, som visas i avsnittet Annan installationskatalog än standard nedan.

### Hur man kompilerar på FreeBSD

Om du vill kompilera och installera &kdevelop; på ett FreeBSD-system, följ de normala instruktionerna, men därefter

- `~/kde3src/kdevelop>` `make -f Makefile.cvs`

måste du göra de särskilda deklarationsfilerna och biblioteken för Berkeley tillgängliga på datorn. Det görs via miljövariabeln `CXXFLAGS`:

- `~/kde3src/kdevelop>` `export CXXFLAGS="-L/usr/X11R6/lib -I/usr/local/include/db41 \`
- `-I/usr/local/include -L/usr/local/lib -I/usr/X11R6/include"`

Du måste ha versionen Berkeley db 4.1 av databasen installerad. Om du har en annan version, måste du justera sökvägen.

#### Kontrollera version av Berkeley databasen

För att ta reda på vilken version av Berkeley databasen som är installerad, kör:

- `~>` `pkg_info | grep db41`

Det ska returnera något som liknar:

    db41-4.1.25_1       The Berkeley DB package, revision 4.1

#### Mer ändringar

Ändra raden

`ac_cv_bdb=no`

till

`ac_cv_bdb=yes`

i filen `configure`, annars hittar inte configure db-biblioteken.

Eftersom `make -f Makefile.cvs` bygger om filen `configure`, måste du dessutom alltid ändra `ac_cv_bdb` värdet varje gång kommandot har utförts.

Eftersom FreeBSD-utvecklarna bytte namn på `libdb.so` till `libdbxx.so` måste du ersätta

`libkdevcatalog_la_LIBADD = -ldb`

med

`libkdevcatalog_la_LIBADD = -ldb41`

i filen `lib/catalog/Makefile.am`.

Fortsätt nu med de vanliga stegen `configure` och `make`, som visas ovan.

### Några anmärkningar om väljare till `configure`

#### Annan installationskatalog än standard

Normalt förbereder `configure` för att installera den grafiska utvecklingsmiljön i &kde;:s standardkatalog. Det behövs, eftersom &kdevelop; antar att det går att direkt komma åt vissa verktyg och delprogram som finns där. Om du vill använda din egen installationskatalog, måste du tala om det för `configure` med väljaren `--prefix`:

- `~/kde3src/kdevelop>` `./configure --prefix=`(där din kde3 finns)

Det finns ett problem om du gör det. Du måste ge möjlighet för &kdevelop; att komma åt nödvändiga verktyg och delprogram i &kde;:s katalog när det kör. (Du kan fortfarande använda den integrerade utvecklingsmiljön utan att göra det, men med mycket begränsade funktioner.)

Starta ett skal och se till att köra följande kommandon innan du startar &kdevelop; från skalet.

Försäkra dig om att använda pluralis: Det är `KDEDIRS`, inte bara `KDEDIR`.

- `~>` `export KDEDIRS=/usr/local/kde:/opt/kde3`
- `~>` `kbuildsycoca`
- (Starta nu &kdevelop;:)
- `~>` `kdevelop`

- Miljövariabeln `KDEDIRS` måste vara inställt till listan med aktiva &kde;-bibliotek i systemet. Vi använder
- `/usr/local/kde`:`/opt/kde3`
- bara som ett exempel.
- Katalogen `/usr/local/kde` kan till exempel innehålla en ofullständig &kde;-version som du kompilerat i avlusningssyfte, och katalogen `/opt/kde3` innehåller dessutom den vanliga &kde;-versionen från distributionen som används för dagligt arbete.

I ett tcsh-skal måste du ställa in miljövariablerna genom att använda:

- `~>` `setenv KDEDIRS /usr/local/kde:/opt/kde3`

Kommandot `kbuildsycoca` (bygg systemkontrollcache) söker efter bibliotek och lagrar deras plats och version i en cache, så att &kdevelop; kan hitta dem. Problemet är att det tar märkbart med tid, och måste köras varje gång du använder skalet för att starta &kdevelop; med en annan installationskatalog än standardkatalogen. Du skulle kunna skriva in ovanstående kommandon i ett skalskript för att reducera ansträngningen att skriva in det.

(Du skulle också kunna skriva in raderna i filen `.bashrc` eller `.cshrc`, men det är inte önskvärt eftersom då körs `kbuildsycoca` varje gång du använder skalet.)

Kommandot `kbuildsycoca` kör inte för systemadministratören. Du måste anropa det som en annan användare. (Men det är inte en särskild god idé att utveckla programvara som systemadministratör!)

## Hur man skaffar dokumentation av programmeringsgränssnittet för &kdevelop;

Programmeringsgränssnittet, Application Program Interface på engelska, ofta förkortat API, innehåller i själva verket en följd av beskrivningar (dvs. anropsmodeller) som ett program kan använda för att komma åt operativsystem och andra tjänster. I vårt fall har dock en mer omfattande definition använts. Programmeringsgränssnittet för ett &kde;- eller &Qt;-program är en sammanfattning av klasser och metodgränssnitt, en översikt som kan användas som uppslagsbok för navigation i källkoden.

Det finns en version av det senaste programmeringsgränssnittet på KDevelops hemsida. Den uppdateras automatiskt varje dygn så att du kan hänga med.

Tyvärr används den här versionen bäst för att bara läsa via Internet. Om du inte alltid är uppkopplad, kan du lika väl bygga din egen dokumentation av programmeringsgränssnittet från källkoden för &kdevelop;. För att göra det, måste du tala om det för automake-systemet var KDELIBS programmeringsgränssnitt finns på din dator. Det kan åstadkommas med den särskilda väljaren `--with-kdelibsdoxy-dir` i kommandot `configure` när du förbereder kompilering av källkoden för &kdevelop;.

- `~/kde3src/kdevelop>` `./configure --`(vanliga väljare)`\`
- `--with-kdelibsdoxy-dir=$KDEDIR/share/doc/HTML/en/kdelibs-apidocs`

(`make` ersätter den globala variabeln `$KDEDIR` med den verkliga inställningen av &kde;-katalogen som finns där). Utför sedan kommandot `make` som vanligt. Efter att den integrerade utvecklingsmiljön &kdevelop; har byggts, har du möjlighet att också bygga programmeringsgränssnittet. För att göra det måste du skriva:

- `~/kde3src/kdevelop>` `make apidocs`

Detta bygger en `Doxyfile` i baskatalogen för &kdevelop;, som i sin tur behandlas av programmet Doxygen för att skapa en hel del `.html`-filer för programmeringsgränssnittet. När den ganska långa byggprocessen (den kan ta mer än en timme på en långsam dator) av programmeringsgränssnittet till sist är klar, måste du installera programmeringsgränssnittet precis som du måste installera själva den integrerade utvecklingsmiljön &kdevelop;. Skaffa rättigheter som systemadministratör om det behövs med:

- `~/kde3src/kdevelop>` `su`

och ange systemadministratörens lösenord. Installera sedan dokumentationsfilerna:

- `~/kde3src/kdevelop>` `make install-apidox`

När det här väl är gjort, informerar `make` dig om katalogen där du till sist kan titta på innehållet i dokumentationen av programmeringsgränssnittet. Observera adressen, eftersom du kan använda den från &konqueror; samt inne i &kdevelop;, om du har ställt in den egna källkoden för &kdevelop; som projektet att arbeta med.

Du ser troligen en mängd varningar och/eller felmeddelanden under tiden programmeringsgränssnittet byggs av Doxygen. Det är bäst att ignorera dem. De är bara av intresse för utvecklare av &kdevelop;. Om programmeringsgränssnittet väl skapats med lyckat resultat, blir dess `.html`-filer användbara.