# Handbok för skriptet &kdesvn-build;

Michael
Pyne

    michael.pyne@kdemail.net

Carlos
Woelz

    carloswoelz@imap-mail.com

Stefan
Asserhäll

    stefan.asserhall@comhem.se

Översättare
2006
2007
2008
Michael Pyne
2005
Carlos Woelz
&FDLNotice;
2008-08-09
1.6.3

&kdesvn-build; är ett skript som bygger och installerar &kde;, direkt från källkoden som hämtas från &kde;:s &subversion;-arkiv.

KDE
kdesdk
SVN
Subversion
KDE-utveckling

## Inledning

&kdesvn-build; är ett skript som hjälper användare att installera &kde; från källkodsarkivet &subversion;.

Här dokumenterar vi syntax och alternativ för &kdesvn-build;s inställningsfil, dess kommandoradsväljare, funktioner och en översikt över alla nödvändiga steg som krävs för att bygga &kde; från källkod, inklusive stegen du måste utföra med användning av andra verktyg, eller med andra ord, steg som inte automatiskt utförs av skriptet &kdesvn-build;.

## Komma igång

I det här kapitlet visar vi hur &kdesvn-build; används för att checka ut moduler från &kde;-arkivet och bygga dem. Vi tillhandahåller också en grundläggande förklaring av &kde;:s &subversion;-struktur och stegen du måste utföra innan skriptet körs.

Alla ämnen som presenteras i det här kapitlet täcks med ännu mer detaljer i guiden Building &kde; from Source Step by Step på hemsidan för &kde;:s kvalitetsgrupp. Om du kompilerar &kde; för första gången, är det en god idé att läsa den, eller rådfråga den som en referenskälla. Du hittar detaljerad information om paketverktyg och krav, vanliga fallgropar vid kompilering och strategier och information om att köra den nya &kde;-installationen.

Dessutom finns en procedur för att bygga &kde; från källkod på &kde;:s Techbase.

### Förbereda systemet för att bygga &kde;

#### Ställa in ett nytt användarkonto

Du rekommenderas att ladda ner och bygga &kde; med ett separat användarkonto. Om du redan har &kde;-paket installerade, är det bästa valet att skapa en annan (särskild) användare för att bygga och köra det nya &kde;. Fördelen med att bygga &kde; för en särskild användare är att du inte kan förstöra bassystemet, och du har alltid ett sätt att arbeta bekvämt när saker och ting går fel.

Senare kan du installera som systemadministratör om du vill. Det här dokumentet täcker inte en installation som systemadministratör. Om du utför en systeminstallation, vet du troligen ändå vad du gör. Om inte, kan du behöva konsultera dokumentation eller hjälpplatser för din distribution, för att utföra och använda systeminstallationen riktigt.

#### Försäkra dig om att systemet är klart att bygga &kde;:s källkod

Innan du använder skriptet &kdesvn-build; (eller någon annan byggstrategi) måste du installera utvecklingsverktyg och bibliotek som behövs för &kde;. Den fullständiga listan med verktyg som behövs finns på sidan &kde;:s kompileringskrav. Krav för &kde; 4 kan hämtas från KDE:s Techbase.

Här är en lista med några av de saker du kommer att behöva:

- Om du bygger &kde; 3, behöver du GNU Autotools (dvs. &automake; och &autoconf;).

- Om du bygger &kde; 4, behöver du &cmake;. Versionen som krävs varierar beroende på vilken version av &kde; 4 du bygger, se TechBase för specifik information.

- Klientprogrammet för &subversion;, inklusive stöd för säker HTTP (https). För att försäkra dig om nödvändigt stöd finns, kan du köra ``svn `--version```. Om modulen ra_dav säger att den hanterar metoden https, ska du vara klar att köra.

- Kompilatorn gcc, med stöd för C++. Version 3.3 eller senare stöds bäst.

- Försäkra dig om att du kontrollerar sidan &kde;:s kompileringskrav för att vara säker på att alla andra bibliotek som krävs är inkluderade.

Ett undantag är &Qt;-biblioteket. &kdesvn-build; installerar normalt en kopia av &Qt; vare sig du har det installerat eller inte, så det är inte nödvändigt att du har det. Om du inte vill använda kopian av &Qt;, måste du göra följande:

- Försäkra dig om att ta bort modulen qt-copy från din inställningsfil eftersom du inte behöver den, och att ha den skulle lägga till extra tid till byggprocessen.

- Ändra inställning av alternativet qtdir i din inställningsfil så att det pekar på systemets &Qt;. Det är normalt samma sak som inställningen av $`QTDIR` i systemet.

- Om du inte redan har installerat &Qt;, installera det, inklusive eventuella relevanta -dev eller -devel paket. Du behöver minst &Qt; 3.3 om du bygger &kde; 3.5 eller &Qt; 4.4 om du bygger &kde; 4.

  Om du bygger &kde; 4 rekommenderas starkt att du använder versionen qt-copy av &Qt;, och försäkrar dig om att du använder rekommenderade programfixar (det är förvald inställning, styrd av alternativet apply-qt-patches).

Vissa av paketen är uppdelade i bibliotek (eller program, eller verktyg) och utvecklingspaket. Du behöver åtminstone programmet eller biblioteket och dess utvecklingspaket. Om du är tveksam, installera alla. Biblioteken du behöver ändras beroende på modulerna du tänker bygga, eftersom varje modul har sina egna krav. &kde; TechBase har mer information om de specifika verktygen och tekniker som används för att installera och hitta programvara som krävs.

#### Inställning av &kdesvn-build;

##### Installera &kdesvn-build;

Du har troligen redan en version av skriptet &kdesvn-build; installerad på systemet. Om du dock inte har det kan du ladda ner det från hemsidan för &kdesvn-build;, eller hämta det från dess hem i &kde;:s källkodsarkiv.

&kdesvn-build; ingår i modulen kdesdk,, och modulen installeras oftast redan av distributioner. Om du har laddad ner &kdesvn-build;, försäkra dig om att du använder versionen du laddat ner. Du kan använda väljaren --version för att vara säker på att du kör den version du tror att du kör.

1. För att ladda ner &kdesvn-build; från dess hemsida, gå helt enkelt till hemsidan för &kdesvn-build; och ladda ner senaste lämpliga utgåva. Utgåvorna paketeras som ett komprimerat tar-arkiv, som du kan packa upp med &ark; eller `tar`. Innehållet i arkivet omfattar själva skriptet &kdesvn-build;, och ett exempel på en inställningsfil (`kdesvn-buildrc-sample`).

2. Annars kan du skaffa &kdesvn-build; från dess källkodsarkiv, på: http://websvn.kde.org/trunk/KDE/kdesdk/scripts/. Det är skriptkatalogen för &kde;:s programvaruutvecklingsverktyg, som är hemkatalog för &kdesvn-build;. Du kan klicka på posten `kdesvn-build`, vilket leder dig till en sida där du kan ladda ner den senaste utgåvan. Gör det, och spara den på ett praktiskt ställe på din hårddisk. Gör samma sak med `kdesvn-buildrc-sample` om du behöver.

Oberoende av vilken teknik du använder, måste du försäkra dig om att filen `kdesvn-build` är körbar. Av bekvämlighetsskäl bör du försäkra dig om att den finns i en katalog som ingår i miljövariabeln `PATH`, annars kan du få meddelanden som säger att kommandot inte hittades, eller kör du kanske en tidigare installerad version av misstag.

##### Färdigställa inställningsfilen

Även om &kdesvn-build; inte kräver att du skapar en inställningsfil, gör det arbetsflödet mycket enklare. Genom att använda en inställningsfil, kan du styra vilka moduler som installeras, eller ta bort moduler du inte vill installera. &kdesvn-build; installerar normalt en användbar &kde;-installation med mycket generella installationsflaggor, som kan skilja sig från dina behov. Det är alltså bäst att använda en inställningsfil

Inställningsfilen ska heta `.kdesvn-buildrc`. Filen ska installeras i hemkatalogen (`~`), och innehålla all inställningsdata som krävs för att skriptet ska kunna köras, som konfigureringsalternativ, kompileringsalternativ, plats för källkoden, installationens mål (prefix), modulerna som ska byggas, etc. Standardinställningsdata tillhandahålls av filen `kdesvn-buildrc-sample`, som du kan kopiera till `~/.kdesvn-buildrc` och därefter redigera.

Du hittar mer information om syntaxen i en inställningsfil i och .

### Ange inställningsinformation

För att använda &kdesvn-build; ska du ha en fil i hemkatalogen som heter `.kdesvn-buildrc` som ställer in allmänna alternativ och anger modulerna som du vill ladda ner och bygga.

Det är möjligt att använda andra inställningsfiler för &kdesvn-build;, som beskrivs i . Om du behöver använda flera inställningar, se det avsnittet.Här antar vi att inställningarna är lagrade i `~/.kdesvn-buildrc`.

Det enklaste sättet att fortsätta är att använda filen `kdesvn-buildrc-sample` som mall, och ändra allmänna inställningar för att stämma med vad du vill ha, och dessutom ändra listan med moduler du vill bygga.

Standardinställningarna bör i själva verket redan vara lämpliga för att utföra byggprocessen för &kde;. Vissa inställningar som du kan vilja ändra omfattar:

- binpath, för att ändra listan med kataloger som söks igenom efter kommandon. Det är precis samma sak som variabeln `PATH` i skalet.

- use-stable-kde för att ändra förvald version av &kde;-moduler att bygga. Normalt bygger &kdesvn-build; &kde;-versionen i trunk (för närvarande &kde; 4). Om du ville bygga den senaste stabila utgåvan av &kde; istället för att använda distributionens paket (för närvarande är &kde; 3.5-grenen stabil) skulle du ändra alternativet till true.

- kdedir, som ändrar målkatalogen som &kde; installeras i. Standardvärdet är `~/kde`, som är en enanvändarinstallation.

- qtdir, som styr sökvägen till installationen av &Qt; att använda. Standardvärdet är att använda modulen qt-copy från &kde;:s &subversion;-arkiv. (`~/kdesvn/build/qt-copy`)

  För Qt-versioner som stöder installation, styr det också var qt-copy ska installeras.

- svn-server, som väljer vilken webbadress som källkoden laddas ner från. Det är användbart om du är en utvecklare med ett &kde; &subversion;-konto.

Efter den allmänna delen finns en lista med moduler att bygga, omgivna av raderna module ... end module. Kontrollera att de listade modulerna verkligen är de moduler du vill bygga. Standardalternativen från filen `kdesvn-buildrc-sample` ska vara tillräckliga för att få en ganska fullständig installation av &kde;. Spara resultatet som `.kdesvn-buildrc` i din hemkatalog.

Om du vill finjustera `.kdesvn-buildrc`, titta då på för detaljerad information om alla inställningsalternativ.

### Att använda skriptet &kdesvn-build;

Nu är du klar att köra skriptet. Logga in till användaren som du använder för att kompilera &kde; i ett terminalfönster, och kör skriptet:

    &percnt;su - utvecklings-användarnamn
    &percnt;kdesvn-build

Nu ska skriptet börja ladda ner källkoden och kompilera den. Beroende på hur många moduler du laddar ner, är det möjligt att &kdesvn-build; inte lyckas första gången du kompilerar &kde;. Ge inte upp hoppet!

&kdesvn-build; loggar utmatningen från varje kommando som körs. Normalt lagras loggfilerna i `~/kdesvn/log`. För att se vad som orsakade ett fel för en modul vid det senaste &kdesvn-build;-kommandot, är det oftast tillräckligt att titta i `~/kdesvn/log/latest/modulnamn/error.log`.

I filen ser du felet som orsakade att byggprocessen misslyckades för modulen. Om filen säger (längst ner) att vissa paket saknas, försök att installera paketet (inklusive eventuella lämpliga -dev paket) innan du försöker bygga modulen, och skicka med väljaren --reconfigure efter att du har installerat de saknade paketen.

Eller om felet verkar vara ett byggfel är det nog ett fel i &kde;:s källkod, som förhoppningsvis löses inom några dagar. Om det inte har lösts inom den tiden, skicka gärna e-post till kde-devel@kde.org (prenumeration kan krävas först) för att rapportera byggfelet.

Du hittar fler vanliga exempel på saker som kan gå fel och deras lösningar, samt allmänna tips och strategier för att bygga &kde;i guiden Building &kde; from Source Step by Step.

För mer information om loggningssystemet i &kdesvn-build;, se .

### Ställa in miljön för att köra det färska &kde;

Med antagandet att du använder en särskild användare för att bygga &kde; och redan har en installerad version av &kde;, kan det vara något krångligt att köra det nya &kde;, eftersom det nya &kde; måste ges företräde över det gamla. Ändra miljövariabler för att försäkra dig om att det gör det.

#### Ändra startprofilinställningar

Filen `.bash_profile` är inloggningsinställningarna för det populära skalet bash som används av många &Linux;-distributioner. Om du använder ett annat skal, kan du behöva justera exemplen som ges i det här avsnittet för ditt specifika skal.

Öppna eller skapa filen `.bash_profile` i hemkatalogen med din favoriteditor, och lägg till följande i slutet på filen. Om du bygger modulen qt-copy (det gör du normalt), lägg till:

    QTDIR=(sökväg till qtdir)   # Såsom normalt ~/kdesvn/build/qt-copy.
    KDEDIR=(sökväg till kdedir) # Såsom normalt ~/kde.
    KDEDIRS=$KDEDIR
    PATH=$KDEDIR/bin:$QTDIR/bin:$PATH
    MANPATH=$QTDIR/doc/man:$MANPATH

    # Gör rätt om inte LD_LIBRARY_PATH redan är satt.
    if [ -z $LD_LIBRARY_PATH ]; then
      LD_LIBRARY_PATH=$KDEDIR/lib:$QTDIR/lib
    else
      LD_LIBRARY_PATH=$KDEDIR/lib:$QTDIR/lib:$LD_LIBRARY_PATH
    fi

    export QTDIR KDEDIRS PATH MANPATH LD_LIBRARY_PATH

eller om du inte bygger qt-copy (och använder systemets &Qt;) lägg till det här istället:

    KDEDIR=(sökväg till kdedir)  # Såsom ~/kde normalt.
    KDEDIRS=$KDEDIR
    PATH=$KDEDIR/bin:$QTDIR/bin:$PATH

    # Gör rätt om inte LD_LIBRARY_PATH redan är satt.
    if [ -z $LD_LIBRARY_PATH ]; then
      LD_LIBRARY_PATH=$KDEDIR/lib
    else
      LD_LIBRARY_PATH=$KDEDIR/lib:$LD_LIBRARY_PATH
    fi

    export KDEDIRS PATH LD_LIBRARY_PATH

Om du inte använder en särskild användare ställ in en annan $`KDEHOME` för din nya miljö i `.bash_profile`:

    export KDEHOME="${HOME}/.kde-svn"

    # Skapa om det behövs
    [ ! -e ~/.kde-svn ] && mkdir ~/.kde-svn

Om din K-meny senare är tom eller för tätpackad med program från din distribution, kanske du måste ange miljövariabeln XDG i din `.bash_profile`:

    XDG_CONFIG_DIRS="/etc/xdg"
    XDG_DATA_DIRS="${KDEDIR}/share:/usr/share"
    export XDG_CONFIG_DIRS XDG_DATA_DIRS

#### Starta &kde;

När du nu har justerat dina miljöinställningar för att använda rätt &kde;, är det viktigt att försäkra dig om att det rätta `startkde`-skriptet också används.

Öppna textfilen `.xinitrc` från hemkatalogen, eller skapa den om det behövs. Lägg till raden:

    exec ${KDEDIR}/bin/startkde

Det kan vara nödvändigt att utföra samma steg med filen `.xsession`, också i hemkatalogen. Det är särskilt sant om grafiska inloggningshanterare som &kdm;, gdm eller xdm används.

Starta nu det nya &kde;: i &BSD;- och &Linux;-system med stöd för virtuella terminaler, används tangentkombinationerna &Ctrl;&Alt;F1 ... &Ctrl;&Alt;F12 för att byta till virtuell konsoll 1 till och med 12. Det låter dig köra fler än en skrivbordsmiljö samtidigt. De första sex är textterminaler, och de följande sex är grafiska skärmar.

Om den grafiska inloggningshanteraren visas istället när du startar datorn, kan du använda den nya &kde;-miljön även om den inte anges som ett alternativ. De flesta inloggningshanterare, inklusive &kdm;, har ett alternativ att använda en Egen session när du loggar in. Med det alternativet laddas dina sessionsinställningar från filen `.xsession` i din hemkatalog. Om du redan har ändrat filen som beskrivs ovan, ska alternativet starta den nya &kde;-installationen.

Om det inte gör det, finns det något annat som du kan prova som normalt ska fungera: Tryck på &Ctrl;&Alt;F2, så visas en textterminal. Logga in som den särskilda användaren och skriv:

    startx -- :1

Du kan köra &kde; från källkod och det gamla &kde; samtidigt. Logga in som din vanliga användare, och starta det stabila &kde;-skrivbordet. Tryck på &Ctrl;&Alt;F2 (eller F1, F3, etc.) så visas en textterminal. Logga in som den särskilda &kde; &subversion;-användaren och skriv:

    startx -- :1

Du kan gå tillbaka till &kde;-skrivbordet för din vanliga användare genom att trycka på snabbtangenten för skrivbordet som redan kör. Den är normalt &Ctrl;&Alt;F7, men du kanske måste använda F6 eller F8 istället. För att returnera till &kde; kompilerat med &kdesvn-build;, ska du använda samma sekvens, utom med nästa funktionstangent. Om du till exempel behövde skriva &Ctrl;&Alt;F7 för att byta till det vanliga &kde;, skulle du behöva skriva &Ctrl;&Alt;F8 för att gå tillbaka till &kde; byggt med &kdesvn-build;.

## Skriptets funktioner

### Översikt över funktioner

Funktionerna i &kdesvn-build; omfattar:

- Stöder meddelandenivåer för utmatning som sträcker sig från att vara mycket tyst till en fullständig felsökningsnivå.

- &kdesvn-build; kan med hjälp av &kdesvn-build;s hemsida och &kde;:s FTP-server (FTP sedan &kdesvn-build; 1.4) tillåta snabb utcheckning av vissa moduler. Om modulen du checkar ut redan har paketerats på hemsidan, laddar &kdesvn-build; ner den versionen och förbereder den för användning på din dator.

  Det är snabbare för dig, och hjälper till att minska lasten på de anonyma &subversion;-servrarna.

- En annan uppsnabbning tillhandahålls genom att starta byggprocessen för en modul så fort källkoden för den modulen har laddats ner (tillgänglig sedan version 1.6).

- Har utmärkt stöd för modulen qt-copy, inklusive valfritt införa felrättningar och optimeringsprogramfixar i modulen qt-copy.

- &kdesvn-build; har färglagd utmatning.

- &kdesvn-build; kräver inte att ett grafiskt gränssnitt är tillgängligt för att fungera. Du kan alltså bygga &kde; utan att behöva en alternativ grafisk miljö.

- Stöder inställning av standardalternativ för alla moduler (som kompileringsinställningarna eller konfigureringsalternativen). Sådana alternativ kan dessutom normalt ändras för specifika moduler.

  Dessutom lägger &kdesvn-build; till standardflaggor där det är lämpligt, för att spara dig besvär och möjliga fel från att skriva in dem själv.

- &kdesvn-build; kan checka ut en särskilt gren eller tagg av en modul. Du kan också försäkra dig om att en specifik revision av en modul checkas ut.

- &kdesvn-build; kan automatiskt ändra källkodskatalog för att checka ut från ett annat arkiv, gren eller tagg. Det sker automatiskt när du ändrar ett alternativ som ändrar vad arkivets webbadress är, men du måste använda väljaren --svn-only för att tala om för &kdesvn-build; att det är acceptabelt att utföra bytet.

- &kdesvn-build; kan checka ut delar av en modul, för de situationer där du bara behöver ett program från en stor modul.

- För utvecklare: &kdesvn-build; kommer att påminna dig om du använder svn+ssh:// men ssh-agent inte kör, eftersom det leder till upprepad begäran om lösenord från &ssh;.

- Kan skicka e-postrapporter med fel till en användare.

- Kan ta bort byggkatalogen för en modul efter den har installerats för att spara utrymme till bekostnad av framtida kompileringstid.

- Platserna för katalogerna som används av &kdesvn-build; kan ställas in (till och med per modul).

- Kan använda &sudo;, eller ett annat användarspecificerat kommando för att installera moduler så att &kdesvn-build; inte behöver köras som systemadministratör.

- &kdesvn-build; kör normalt med reducerad prioritet för att låta dig fortsätta använda datorn medan &kdesvn-build; arbetar.

- Har stöd för att använda &kde;:s &subversion; taggar och grenar.

- &kdesvn-build; använder en uppsättning tekniker för att försöka garantera en lyckad byggprocess.

- Det finns stöd för att återuppta en byggprocess från en given modul. Du kan till och med ignorera vissa moduler tillfälligt för en given byggprocess.

- &kdesvn-build; kan snabbt utföra en partiell byggprocess för en modul direkt från kommandoraden, när du bara behöver uppdatera en del av en modul.

- &kdesvn-build; laddar automatiskt ner och skapar det nödvändiga biblioteket `/admin` för en modul om den inte laddas ner från &subversion; första gången, av någon orsak. Det gäller bara för &kde; 3-moduler, eftersom /admin inte krävs för qt-copy eller &kde; 4-moduler.

- &kdesvn-build; visar förloppet för byggprocessennär &unsermake; och &cmake; används, och tar alltid tid på byggprocessen så att du i efterhand vet hur lång tid den tog.

- Försöker automatiskt bygga om moduler som använder en inkrementell byggprocess, vilken tenderar att misslyckas efter vissa typer av incheckningar.

- Levereras med en inbyggt rimlig uppsättning förvalda alternativ lämpligt för att bygga en grundläggande enanvändarinstallation av &kde; från det anonyma &subversion;-arkivet.

- Levereras med stöd för &unsermake;.

- Expanderar dina inställningsalternativ med tilde. Du kan till exempel ange:

      qtdir ~/kdesvn/build/qt-copy

- Ställer automatiskt in ett byggsystem med källkodskatalogen skild från byggkatalogen, för att hålla källkodskatalogen orörd.

- Du kan ange allmänna alternativ att använda för alla moduler som checkas ut, och du kan dessutom ange alternativ som ska användas för enskilda moduler.

- Eftersom autoverktygen ibland blir osynkroniserade med ändringar i källkodsträdet, kan du tvinga att en modul byggs om genom att skapa en fil som heter refresh-me i byggkatalogen för modulen i fråga, eller genom att köra &kdesvn-build; med väljaren `--refresh-build`.

- Du kan ange diverse miljövariabler som ska användas under byggprocessen, inklusive `KDEDIR`, `QTDIR`, `DO_NOT_COMPILE` och `CXXFLAGS`.

- Kommandologgning. Loggar dateras och numreras så att du alltid har en logg av en körning av skriptet. Dessutom skapas en symbolisk länk som heter latest, som alltid pekar på den senaste loggen i loggkatalogen.

- Om du använder en användarbyggd &kde; istället för en systembyggd (som du måste vara systemadministratör för att installera), kan du låta skriptet installera åt dig. Jag har inte granskat koden, och den använder anropet `system()` flitigt, så jag rekommenderar för närvarande att inte köra den som systemadministratör.

- Du kan använda make-install-prefix för att inleda kommandoraden ``make` `install`` med ett separat kommando, vilket är användbart för &sudo;.

- Du kan checka ut bara en delmängd av en &kde; &subversion;-modul. Du skulle till exempel kunna checka ut bara taglib från kdesupport, eller bara K3B från extragear/multimedia. Skriptet hämtar automatiskt in kde-common om det behövs för att få byggprocessen att fungera.

- Du kan låtsas att utföra åtgärden. Om du skickar med `--pretend` eller `-p` på kommandoraden, ger skriptet en mycket utförlig beskrivning av de kommandon som ska göras, utan att i själva verket utföra dem.

### Byggloggning i &kdesvn-build;

#### Översikt över loggning

Loggning är en funktion i &kdesvn-build; varigenom utmatningen från varje kommando som &kdesvn-build; kör sparas i en fil för senare undersökning, om nödvändigt. Det görs eftersom det ofta är nödvändigt att ha utmatningen från programmen när ett byggfel uppstår, eftersom det finns så många orsaker att en byggprocess kan misslyckas från början.

##### Loggningskatalogens layout

Loggarna lagras alltid i loggkatalogen. Platsen för loggkatalogen styrs av alternativet log-dir, som normalt är `${source-dir}/log` (där ${source-dir} är värdet av alternativet source-dir. I resten av avsnittet kallas värdet ${log-dir}).

I ${log-dir} finns en uppsättning kataloger, en för varje gång &kdesvn-build; kördes. Varje katalog namnges med datum och körnumret. Exempelvis, den andra gången &kdesvn-build; körs 26:e maj, 2004, skulle en katalog som heter `2004-05-26-02` skapas, där 2004-05-26 står för datumet och -02 är körnumret.

För din bekvämlighet skapar &kdesvn-build; också en länk till loggarna för den senaste körningen, som heter `latest`. Loggarna för den senaste körningen av &kdesvn-build; ska alltid finnas under `${log-dir}/latest`.

Varje katalog för en körning av &kdesvn-build; innehåller nu i sin tur en uppsättning kataloger, en för varje &kde;-modul som &kdesvn-build; försöker bygga. Dessutom finns en fil som heter `build-status` i katalogen, som låter dig avgöra vilka moduler som byggdes och vilka som misslyckades.

Om en modul själv har en delmodul (såsom extragear/multimedia, playground/utils eller KDE/kdelibs), finns i själva verket motsvarande struktur i loggkatalogen. Loggarna för KDE/kdelibs efter den senaste körningen av &kdesvn-build; finns till exempel i `${log-dir}/latest/KDE/kdelibs`, och inte i `${log-dir}/latest/kdelibs`.

Du hittar en uppsättning filer för varje åtgärd som &kdesvn-build; utför i varje modulloggkatalog. Om &kdesvn-build; uppdaterar en modul, kan du se filnamn såsom `svn-co.log` (för en utcheckning av en modul) eller `svn-up.log` (när en modul uppdateras som redan har checkats ut). Om kommandot `configure` kördes, kan du förvänta dig att se filen `configure.log` i katalogen.

Om ett fel uppstod, bör du kunna se en förklaring av varför i en av filerna. För att hjälpa till att avgöra vilken fil som innehåller felet, skapar &kdesvn-build; en länk från filen med felet (såsom `build-1.log` till en fil som heter `error.log`).

Slutresultatet av allt detta är att för att se varför en modul misslyckades byggas efter den senaste körningen av &kdesvn-build;, är filen du först ska titta i `${log-dir}/latest/modulnamn/error.log`.

Om filen `error.log` är tom (särskilt efter en installation), kanske det inte var något fel. Vissa verktyg som används av &kde;:s byggsystem rapporterar ibland av misstag ett fel när det inte fanns något.

Dessutom kringgår några kommandon omdirigeringen av utmatning som &kdesvn-build; gör, och går förbi loggfilen under vissa omständigheter (normalt när den första utcheckningen från &subversion; sker), och felutmatningen finns inte i loggfilen i detta fall, utan istället i terminalen där &kdesvn-build; kördes

## Formatet för .kdesvn-buildrc

För att använda skriptet måste du ha en fil i din hemkatalog som heter `.kdesvn-buildrc`, som beskriver modulerna som du vill ladda ner och bygga.

Den börjar med allmänna alternativ, angivna enligt följande:

    global
    alternativ-namn alternativ-värde
    [...]
    end global

De följs därefter av en eller flera modulsektioner, angivna på följande sätt:

    module modul-namn
    alternativ-namn alternativ-värde
    [...]
    end module

modul-namn måste vara en modul i &kde;:s &subversion;-arkiv (till exempel kdelibs eller kdebase). Vissa alternativ överskrider de allmänna alternativen, vissa lägger till i de allmänna alternativen och vissa allmänna alternativ kan helt enkelt inte överskridas.

Följande är en alfabetisk lista med alternativ du kan använda. Klicka på alternativet för att ta reda på mer om det. Om något inte är dokumenterat, skicka gärna e-post till upphovsmännen med adressen som du hittar ovan.

- apply-qt-patches, för att förbättra qt-copy.

- async, för att uppdatera och bygga samtidigt.

- binpath, för att ställa in variabeln `PATH`.

- branch, för att checka ut från en gren istället för /trunk.

- build-dir, för att ange katalog att bygga i.

- checkout-only, för att bara checka ut delar av en modul.

- cmake-options för att ange vilka flaggor en modul ska ställas in med vid användning av &cmake;.

- colorful-output för att lägga till färg i skriptets utmatning.

- configure-flags för att ange vilka flaggor en modul ska ställas in med.

- cxxflags för att definiera variabeln `CXXFLAGS`.

- dest-dir för att ändra katalognamn för en modul.

- disable-agent-check, för att förhindra att &kdesvn-build; kontrollerar ssh-agentens status.

- do-not-compile, för att markera kataloger så att de hoppas över av byggprocessen.

- inst-apps, för att bara bygga och installera vissa kataloger.

- install-after-build, för att undvika att installera efter byggprocessen.

- kdedir, för att ange katalogen där &kde; ska installeras.

- kde-languages, för att ställa in översättningspaketen att ladda ner och installera.

- libpath, för att sätta variabeln `LD_LIBRARY_PATH`.

- make-install-prefix, för att köra ett hjälpprogram (som &sudo;) under ``make` `install``.

- make-options, för att skicka väljare till byggprogrammet &make;.

- manual-build, för att undvika att modulen byggs automatiskt.

- manual-update, för att undvika att någonting görs automatiskt med modulen.

- module-base-path, för att ändra varifrån modulen laddas ner.(användbart för grenar och taggar).

- niceness, för att ändra processorprioriteten.

- no-rebuild-on-fail, för att undvika att köra &make; igen om det misslyckas.

- qtdir, för att ange sökvägen till &Qt;.

- set-env, för att sätta en miljövariabel.

- source-dir, för att ändra vart källkoden laddas ner.

- stop-on-failure, för att få .&kdesvn-build; att stoppa så fort ett allvarligt fel hittas.

- svn-server, för att ändra servern som källkoden automatiskt laddas ner från.

- use-unsermake, för att använda det avancerade byggsystemet &unsermake;.

Här är en tabell över de olika alternativen, och några kommentarer om dem. Alla alternativ som överskrider det allmänna alternativet, överskrider också en kommandoradsväljare.

### Alternativtabell

Alternativnamn | Modul -> Allmänt beteende | Anmärkningar
--- | --- | ---

apidox

Överskrider allmän

Alternativet användes för att tillåta att KDE-modulens dokumentation av programmeringsgränssnitt byggdes. Det togs bort i &kdesvn-build; 1.6.3 eftersom det inte stöds i KDE 4. Dokumentation av programmeringsgränssnitt är tillgänglig på kde.org. Dessutom är det möjligt att bygga dokumentation av programmeringsgränssnittet i KDE 4 med ett skript som ingår i modulen kdesdk (i katalogen /scripts). Se KDE TechBase för ytterligare detaljinformation. Det är förstås fortfarande möjligt att bygga dokumentation av programmeringsgränssnittet för äldre moduler manuellt.

apply-qt-patches

Överskrider allmän

Alternativet är bara användbart för qt-copy. Om det är inställt till ett värde skilt från noll, körs skriptet apply-patches i qt-copy innan byggprocessen, för att införa de inofficiella programfixarna i qt-copy. Eftersom programfixarna normalt är orsaken att använda qt-copy istället för en vanlig &Qt;, bör det inte skada att aktivera det. Standardvärdet är att aktivera programfixarna.

async

Kan inte överskridas

Alternativet aktiverar asynkront användningssätt, där uppdatering av källkoden och byggprocessen utförs i parallell, istället för att vänta på alla uppdateringar av källkoden innan byggprocessen startas. Alternativets förvalda värde är att aktivera asynkront användningssätt. För att inaktivera, ställ in alternativet till false.

Alternativet är tillgängligt från och med utgåva 1.6.

binpath

Överskrider allmän

Sätt alternativet för att använda miljövariabeln PATH under byggprocessen. Du kan inte överskrida alternativet i ett modulalternativ. Förvalt värde är `/bin:/usr/bin:/usr/local/bin:/usr/X11R6/bin`. Miljövariabeln ska innehålla sökvägar till utvecklingsverktygen åtskilda med kolon. Sökvägarna `$`KDEDIR`/bin` och `$`QTDIR`/bin` läggs automatiskt till. Du kan använda tilde (~) för eventuella sökvägar du lägger till med det här alternativet.

branch

Överskrider allmän

Ställ in alternativet för att checka ut från en gren av &kde; istället för standardvärdet trunk där utveckling av &kde; sker. För att till exempel checka ut grenen &kde; 3.4, skulle du ställa in alternativet till 3.4.

Observera att vissa moduler använder ett annat grennamn. I synnerhet, använder inte den nödvändiga modulen arts &kde;:s versionsnummer. Modulen arts som hör ihop med &kde; 3.4 hade version 1.4.

Om &kdesvn-build; misslyckas med att ladda ner en gren med alternativet, kan du behöva ange webbadressen att ladda ner från för hand med alternativet override-url.

build-dir

Överskrider allmän

Använd det här alternativet för att byta katalog som innehåller källkoden att bygga. Det finns tre olika sätt att använda det:

- Relativt till &kde;:s &subversion;-källkodskatalog (se alternativet source-dir). Det är förvalt, och sättet som skriptet fungerade fram till version 0.61. Läget väljes om du skriver in ett katalognamn som inte börjar med tilde (~) eller snedstreck (/).

  Förvalt värde är `build`

- Absolut sökväg. Om du anger en sökväg som börjar med /, används sökvägen direkt. Till exempel `/tmp/kde-obj-dir/`

- Relativt till din hemkatalog. Om du anger en sökväg som börjar med ~, används sökvägen relativt till din hemkatalog, på motsvarande sätt som skalets expansion av tilde. Till exempel skulle `~/builddir` ställa in byggkatalogen till `/home/användarnamn/builddir`

Alternativet kan, kanske något oväntat, ändras per modul.

checkout-only

Överskrider allmän

Sätt det här alternativet för att checka ut källkod från &subversion; del för del. Värdet av alternativet ska vara en lista med kataloger åtskilda med mellanslag att checka ut. Om du inte inkluderar katalogen admin, inkluderas den automatiskt (om det behövs). När du checkar ut del för del hämtas katalogen admin in från kde-common, vilket är platsen den finns på &subversion;-servern. Även om alternativet överskrider det allmänna alternativet, var medveten om att ange alternativet som ett allmänt alternativ inte är vettigt.

cmake-options

Lägger till i allmänna alternativ (utom för qt-copy)

Använd det här alternativet för att ange vilka flaggor som ska skickas till &cmake; när byggsystemet för modulen skapas. När det används som ett allmänt alternativ, används det för alla moduler som skriptet bygger. När det används som ett modulalternativ, läggs det till i slutet av de allmänna alternativen. Det låter dig ange gemensamma &cmake;-alternativ i den allmänna delen.

Alternativet ersätter configure-flags för &kde; 4-moduler, eftersom de använder &cmake; för att byggas.

Eftersom alternativen skickas direkt till kommandoraden för &cmake;, ska de anges som de skulle skrivits till &cmake;. Till exempel:

    cmake-options -DCMAKE_BUILD_TYPE=RelWithDebInfo

Eftersom det är krångligt, anstränger sig &kdesvn-build; för att så länge övriga alternativ är rätt inställda, ska du kunna lämna det här alternativet tomt.

configure-flags

Lägger till i allmänna alternativ (utom för qt-copy)

Använd det här alternativet för att ange vilka flaggor som ska skickas till ./configure när byggsystemet för modulen skapas. När det används som ett allmänt alternativ, används det för alla moduler som skriptet bygger. qt-copy använder en mycket annorlunda uppsättning inställningsalternativ än resten av &kde;, så det här alternativet överskrider de globala inställningarna när det används för qt-copy.

Alternativet gäller för qt-copy och alla &kde; 3-moduler. &kde; 4-moduler använder &cmake;, som styrs med alternativet cmake-options.

colorful-output | Kan inte överskridas | Ställ in alternativet till false för att inaktivera den färgglada utmatningen från &kdesvn-build;. Alternativet har standardvärdet true. Observera att &kdesvn-build; inte matar ut färgkoder till något annat än en terminal (såsom xterm, &konsole; eller den vanliga konsollen i &Linux;).

cxxflags

Lägger till i allmänna alternativ

Använd det här alternativet för att ange vilka flaggor som ska skickas till `./configure` som `CXXFLAGS` när byggsystemet för modulen skapas. Alternativet anges här istället för med configure-flags eller cmake-options eftersom alternativet också sätter miljövariabeln `CXXFLAGS` under byggprocessen.

Observera att för &kde; 4 och alla andra moduler som använder &cmake;, är det nödvändigt att ställa in alternativet CMAKE_BUILD_TYPE option till "none" när modulen konfigureras. Det kan göras med alternativet cmake-options.

dest-dir

Överskrider allmän

Använd alternativet för att ändra namnet en modul får på disk. Om modulen till exempel är extragear/network, skulle du kunna ändra det till extragear-network med det här alternativet. Observera att även om detta ändrar modulens namn på disk, är det inte en god idé att låta kataloger eller katalogåtskiljare ingå i namnet, eftersom det kommer i konflikt med eventuella build-dir eller source-dir alternativ.

disable-agent-check

Kan inte överskridas

Om du använder &ssh; för att ladda ner källkod från &subversion; (om du använder protokollet svn+ssh), försöker &kdesvn-build; normalt att försäkra sig om att när du använder ssh-agent, så hanterar det verkligen några &ssh;-identiteter. Det görs för att försöka förhindra att &ssh; frågar efter din lösenordsfras för varje modul. Du kan inaktivera kontrollen genom att sätta `disable-agent-check` till true.

do-not-compile

Överskrider allmän

Använd alternativet för att välja en specifik uppsättning kataloger att bygga i en modul (istället för alla). Katalogerna att bygga ska skiljas åt med mellanslag.

Funktionen stöds både för &kde; 3 och &kde; 4. Stöd för KDE 4 lades till i &kdesvn-build; 1.6.3.

Observera att källkoden till programmen fortfarande laddas ner. Du kan använda direktivet checkout-only för att välja kataloger som du vill checka ut.

För att till exempel vänta med kompilering av &juk; och &kscd; i modulen kdemultimedia, ska du lägga till "do-not-compile juk kscd" i inställningarna för kdemultimedia.

email-address | Kan inte överskridas | Ställ in alternativet till e-postadressen som &kdesvn-build; ska skicka från om det någonsin behöver skicka e-post. Du behöver inte bekymra dig om det om du inte använder någon funktion som skickar e-post (De är alla normalt inaktiverade). För närvarande behöver bara email-on-compile-error alternativet.

email-on-compile-error

Kan inte överskridas

Du kan ställa in alternativet till e-postadressen dit en rapport ska skickas när en modul misslyckas bygga. &kdesvn-build; väntar till alla moduler är klara och samlar alla resultat i rapporten. Rapporten skickas bara om en modul misslyckas bygga.

Se alternativet email-address för att ställa in adressen som &kdesvn-build; ska skicka från, eftersom förvalt värde oftast inte är vad du vill ha.

inst-apps

Överskrider allmän

Det här är motsatsen till alternativet do-not-compile. Alternativet gör så att bara de angivna toppnivåkatalogerna byggs. Katalogerna ska vara åtskilda med mellanslag.

Eventuella ändringar får ingen effekt förrän nästa gång `make `-f` Makefile.cvs` körs, antingen automatiskt av skriptet, eller manuellt med alternativen `--refresh-build` eller `--recreate-configure`.

Det här alternativet fungerar ännu inte för moduler som byggs med byggsystemet &cmake;.

Observera att källkoden till programmen fortfarande laddas ner. Du kan använda direktivet checkout-only för att välja kataloger som du vill checka ut.

install-after-build | Överskrider allmän | Alternativet används för att installera paketet efter det har byggts med lyckat resultat. Alternativet är normalt aktiverat. Om du vill inaktivera det, måste du ställa in alternativet till 0 i inställningsfilen. Du kan också använda kommandoradsväljaren `--no-install`.
kdedir | Överskrider allmän | Det här alternativet anger katalogen som &kde; installeras i efter det har byggts. Förvalt värde är `~/kde`. Om du ändrar det till en katalog som kräver åtkomst som systemadministratör, bör du också läsa om alternativet make-install-prefix.

kde-languages

Kan inte överskridas

Alternativet låter dig välja att ladda ner och installera landsinställningspaket tillsammans med &kde;. Du kan göra det om du inte bor i Förenta Staterna och vill ha &kde; översatt till ditt modersmål.

Ställ in alternativet till en lista av språk att installera separerade med mellanslag, för att använda det. Varje språk har en tillhörande språkkod, som du kan slå upp på följande sida: http://i18n.kde.org/teams/.

Det är helt riktigt att bara välja ett språk. Normalt laddas inga ner, vilket betyder att &kde; visas med amerikansk engelska.

Exempelvis, för att välja att installera svenska, skulle du ställa in alternativet till något liknande: ``kde-languages` sv`. Du måste dock ändå använda Inställningscentralen för att välja svenska språket.

libpath | Överskrider allmän | Ange det här alternativet för att sätta miljövariabeln LD_LIBRARY_PATH under byggprocessen. Du kan inte överskrida inställningen med ett modulalternativ. Förvalt värde är tomt, men sökvägarna `$`KDEDIR`/lib` och `$`QTDIR`/lib` läggs automatiskt till. Du kan använda tilde (~) i alla sökvägar du lägger till med alternativet.
log-dir | Överskrider allmän | Använd det här alternativet för att ändra katalogen som används för att lagra loggfiler som skapas av skriptet. Inställningen kan ändras per modul från och med version 0.64 eller senare.
make-install-prefix | Överskrider allmän | Sätt den här variabeln till en lista åtskilda med mellanslag, som tolkas som ett kommando och dess väljare för att föregå kommandot ``make` `install`` som används för att installera moduler. Det är användbart för att till exempel installera paket med &sudo;, men var försiktig när du hanterar systemadministratörsrättigheter.
make-options | Överskrider allmän | Ange den här variabeln för att skicka kommandoradsväljare till kommandot `make`. Det är användbart för program som distcc eller system med mer än en processorkärna.
manual-build | Överskrider allmän | Sätt alternativvärdet till true för att förhindra att byggprocessen försöker bygga modulen. Den hålls fortfarande uppdaterad vid uppdatering från &subversion;. Alternativet motsvarar exakt kommandoradsväljaren `--no-build`.
manual-update | Överskrider allmän | Sätt alternativvärdet till true för att förhindra att byggprocessen försöker uppdatera (och som en följd, bygga eller installera) modulen. Om du anger alternativet för en modul, är det i stort sett samma som att kommentera bort den.

module-base-path

Överskrider allmän

Sätt det här alternativet för att överskrida &kdesvn-build;s förvalda katalogväg till modulen i fråga. Det kan till exempel användas för att hämta specifika grenar eller taggade versioner av bibliotek. &kde;:s källkodsvisning är ovärderlig som hjälp för att välja rätt sökväg.

Observera att &kdesvn-build; konstruerar den slutliga sökvägen enligt följande mall: `$svn-server`/home/kde/`$module-base-path`/`$module-name`.

Standardvärdet är antingen trunk eller trunk/KDE beroende på modulnamnet.

Använd alternativen branch eller tag istället så snart de är tillämpliga.

niceness | Kan inte överskridas | Ställ in alternativet till ett tal mellan 20 och 0. Ju högre nummer, desto lägre prioritet ställer &kdesvn-build; in åt sig själv. Förvalt värde är 10.
no-svn | Överskrider allmän | Om alternativet är sant, uppdaterar inte &kdesvn-build; modulens källkod automatiskt. Det försöker i alla fall bygga modulen om det normalt ändå hade försökt göra det.
no-rebuild-on-fail | Överskrider allmän | Ställ in det här alternativvärdet till true för att alltid förhindra att &kdesvn-build; försöker bygga om modulen om en inkrementell byggprocess skulle misslyckas. Normalt försöker &kdesvn-build; bygga om modulen från början för att motverka effekten att en enstaka &subversion;-uppdatering orsakar problem med byggsystemet.
override-url | Överskrider allmän | Om du anger det här alternativet, använder &kdesvn-build; dess värde som webbadress att skicka till &kdesvn-build; helt oförändrad. Du bör i allmänhet använda det om du vill ladda ner en specifik utgåva, men &kdesvn-build; inte kan räkna ut vad du menar genom att använda branch.
qtdir | Överskrider allmän | Sätt alternativet för att använda miljövariabeln `QTDIR` under byggprocessen. Du kan inte överskrida alternativet i ett modulalternativ. Förvalt värde är `$(source-dir)/build/qt-copy`, som använder modulen qt-copy som ingår i &kde;:s källkodsarkiv. Du kan använda tilde (~) för att representera din hemkatalog.

remove-after-install

Överskrider allmän

Om du har ont om hårddiskutrymme kan du vilja använda det här alternativet för att automatiskt ta bort byggkatalogen (eller både källkatalogen och byggkatalogen för engångsinstallationer) efter modulen har installerats med lyckat resultat.

Möjliga värden för alternativet är:

- none - Ta inte bort någonting (det är normalvärdet).

- builddir - Ta bort byggkatalogen men inte källkoden.

- all - Ta både bort källkoden och byggkatalogen.

Observera att användning av alternativet kan ha en markant effekt både på användning av bandbredd (om du använder all) och tiden det tar att kompilera &kde;, eftersom &kdesvn-build; inte kommer att kunna utföra inkrementella byggprocesser.

revision | Överskrider allmän | Om alternativet ställs in till ett annat värde än 0 (noll), tvingar &kdesvn-build; uppdateringen med &subversion; att ge modulen exakt den version som anges, även om alternativ som branch gäller. Om modulen redan har angiven version, kommer den inte att uppdateras ytterligare om inte alternativet ändras eller tas bort från konfigurationen.

set-env

Överskrider allmän

Det här alternativet accepterar en uppsättning värden åtskilda av mellanslag, där det första värdet är miljövariabeln att sätta, och följande värden är vad du vill sätta variabeln till. För att till exempel sätta variabeln `RONALD` till McDonald, skulle du skriva följande kommando under lämplig sektion:

    set-env RONALD McDonald

Alternativet är särskilt på det sätt att det kan upprepas utan att överskrida tidigare inställningar av set-env i samma del av inställningsfilen. På så sätt kan du ställa in mer än en miljövariabel per modul (eller allmänt).

source-dir | Överskrider allmän | Det här alternativet används för att ange katalogen på datorn där &kde;:s &subversion;-källkod ska lagras. Om du inte anger värdet, är förvalt värde `~/kdesvn`. Om du anger värdet, använd en absolut sökväg.
stop-on-failure | Överskrider allmän | Ställ in det här alternativvärdet till true för att göra att skriptet slutar köra efter ett fel uppstår i bygg- eller installationsprocessen. Alternativet är normalt av.
svn-server | Överskrider allmän | Det här alternativet används för att ange servern som används vid utcheckning från &subversion;. Förval är det anonyma &subversion;-arkivet, svn://anonsvn.kde.org/

tag

Överskrider allmän

Använd väljaren för att ladda ner en specifik utgåva av en modul.

Observera: Chansen är mycket stor att du inte vill använda alternativet. Utgåvor av &kde; är tillgängliga som komprimerade tar-arkiv från &kde;:s FTP-plats eller en av dess spegelplatser.

Om du använder &kdesvn-build; eftersom du har svårighet att få en utgåva av &kde; att byggas på din distribution, fundera på att använda byggverktyget Konstruct istället, som arbetar med utgivna komprimerade tar-arkiv.

unsermake-options | Överskrider allmän | Väljaren är precis som make-options men för &unsermake;, som accepterar vissa väljare som `make` inte kan förstå.
use-cmake | Överskrider allmän | Väljaren togs bort i &kdesvn-build; 1.4, eftersom alla &kde; 4-moduler kräver &cmake;, och användning av &cmake; inte tillåts för några andra moduler.

use-qt-builddir-hack

Överskrider allmän

Även om alternativet överskrider det allmänna alternativet, är det bara vettigt för qt-copy. Sätt alternativet till true för att aktivera skriptets läge med källkatalog skild från byggkatalog. När det är aktiverat, kopierar &kdesvn-build; qt-copy källkodsmodulen till byggkatalogen, och utför byggprocessen därifrån. Det betyder att miljövariabeln `QTDIR` istället ska vara inställd till `$(qt-copy-build-dir)/qt-copy/lib`. Du måste också ändra alternativet qtdir på motsvarande sätt. Att bygga inkrementellt ska fortfarande fungera med detta läge, eftersom tidsstämplar bevaras efter kopieringen. Om du använder alternativet apply-qt-patches, utföra programfixarna i byggkatalogen, inte källkodskatalogen. Alternativets förvalda värde är true.

use-stable-kde

Kan inte överskridas

Eftersom &kdesvn-build; har stöd för att bygga &kde; 3 och 4, måste det finnas något sätt att tala om vilken version som ska byggas. Normalt bygger &kdesvn-build; huvudversionen för utveckling av &kde; (som kallas /trunk). Men den är för &kde; 4, som ännu inte är redo för en bred utgåva.

Du kan använda alternativet &branch; allmänt, eller för en modul för att ladda ner för &kde; 3.5 (eller 3.4, etc.). Det är dock inte bekvämt, eftersom vissa moduler (som kdesupport) delas mellan 3.5 och 4. Dessutom är det en mängd grenalternativ som måste läggas till i inställningsfilen.

Om du alltså ställer in det allmänna alternativet till true, laddar &kdesvn-build; automatiskt ner &kde; 3.5 versionen av moduler som kdelibs och qt-copy, istället för att ladda ner &kde; 4 versionen. Du kan fortfarande använda alternativen &branch; eller &tag; för en modul för att överskrida inställningarna som &kdesvn-build; väljer. På så sätt kan du enkelt välja att ladda ner &kde; 3.5 istället för förutgåvan &kde; 4.

use-unsermake

Överskrider allmän

Sätt det här alternativet till true för att använda det experimentella programmet &unsermake; istället för &automake; när skriptet configure körs. Det kan orsaka väsentlig minskning av byggtiden, särskilt för distribuerade byggsystem. Alternativets förvalda värde är true (för de flesta moduler).

Normalt, om du använder alternativet kommer &kdesvn-build; automatiskt att hålla &unsermake; uppdaterat. Det kan börja bli irriterande, särskilt om du hanterar &unsermake; själv Om det är fallet, kan du sätta alternativet till self, så använder &kdesvn-build; fortfarande &unsermake;, men gör ingenting särskilt för att hålla det uppdaterat.

## Kommandoradsväljare och miljövariabler

Skriptet använder inte miljövariabler. Om du behöver sätta miljövariabler för bygg- eller installationsprocessen, se alternativet set.-env.

Skriptet accepterar följande kommandoradsväljare:

`--async`

  Aktiverar asynkront användningssätt för att uppdatera och bygga samtidigt. Det är förvalt värde, och väljaren behöver bara anges om du har inaktiverat det i inställningarna.

`--help`

  Visa bara enkel hjälp om skriptet.

`--version`

  Visa programmets version.

`--author`

  Visa upphovsmannens kontaktinformation.

`--color`

  Aktivera färglagd utmatning.

`--nice=värde`

  Ställer in snällhetsvärdet till värde under den här körningen. värde ska vara mellan 0 och 20.

`--no-async`

  Inaktiverar asynkront användningssätt för uppdateringar. Istället utförs hela uppdateringen innan byggningen startas. Väljaren slöar ner totalprocessen, men om du råkar ut för IPC-fel medan du kör &kdesvn-build;, prova den här väljaren, och skicka in en felrapport.

`--no-color`

  Inaktivera färglagd utmatning.

`--pretend` (eller `-p`)

  Utför inte någonting, men beter sig som om det vore så.

`--quiet` (eller `-q`)

  Var inte så högljudd med utmatningen. Med den här väljaren matas bara det viktigaste ut.

`--really-quiet`

  Mata bara ut varningar och fel.

`--verbose`

  Beskriv i detalj vad som händer, och vad &kdesvn-build; gör.

`--svn-only`

  Utför bara uppdatering av källkoden.

`--build-only`

  Utför bara byggprocessen.

`--ignore-modules`

  Inkludera inte moduler som skickas på resten av kommandoraden under uppdaterings- och byggprocessen.

`--no-svn`

  Hoppa över att kontakta &subversion;-servern.

`--no-build`

  Hoppa över byggprocessen.

`--no-install`

  Installera inte automatiskt paket efter de har byggts.

`--debug`

  Aktiverar felsökningsläge för skriptet. För närvarande betyder det att all utmatning skickas till standardutmatningen förutom att loggas i loggkatalogen som vanligt. Dessutom är många funktioner mycket utförligare om vad de gör i felsökningsläge.

`--no-rebuild-on-fail`

  Försök inte att bygga om moduler som har misslyckats att byggas från början. &kdesvn-build; försöker aldrig göra detta med en modul där ett försök att bygga från början redan har gjorts.

`--refresh-build`

  Skapa om byggsystemet och bygg från grunden.

`--reconfigure`

  Kör skriptet configure igen utan att rensa byggkatalogen.

`--recreate-configure`

  Kör `make `-f` Makefile.cvs` igen för att skapa skriptet configure, och fortsätt bygga som vanligt. Alternativet inbegriper `--reconfigure`.

`--resume-from`

  Alternativet är användbart för att återuppta byggprocessen från den angivna modulen, som ska vara nästa alternativ på kommandoraden. Alternativet inbegriper `--no-svn`. Du ska inte ange andra modulnamn på kommandoraden.

`--rc-file`

  som tolkar nästa kommandoradsväljare som filen att läsa konfigurationsinställningarna från. Förvalt värde för väljaren är ~/.kdesvn-buildrc.

`--run`

  Alternativet tolkar nästa parameter på kommandoraden som ett program att köra, och &kdesvn-build; slutar då att läsa inställningsfilen, uppdaterar miljön som vanligt, och kör därefter angivet program.

  Det fungerar dock inte för att starta ett skal med miljön från &kdesvn-build; i de flesta fall, eftersom interaktiva skal typiskt återställer åtminstone vissa av miljövariablerna (som `PATH` och `KDEDIRS`) under startsekvensen.

`--prefix=</sökväg/till/kde>`

  Det här låter dig ändra katalogen som &kde; installeras i från kommandoraden. Alternativet inbegriper `--reconfigure`.

`--build-system-only`

  Stoppa efter att ha kört `make `-f` Makefile.cvs`. Skriptet configure behöver fortfarande köras, vilket &kdesvn-build; gör nästa gång. Detta låter dig förbereda alla konfigureringsskript på en gång så att du kan titta på `./configure `--help`` för varje modul, och redigera dina flaggor till configure i enlighet med det.

`--install`

  Om detta är den enda kommandoradsväljaren, försöker skriptet installera alla moduler som har byggts med lyckat resultat, förutom qt-copy som inte behöver installeras. Om kommandoradsväljare anges efter `--install`, antas de alla vara moduler att installera.

`--<option-name>=`

  Du kan använda alternativet för att överskrida ett alternativ i inställningsfilen för alla moduler. För att till exempel överskrida alternativet log-dir, skulle du skriva ``--log-dir=`/sökväg/till/katalog```.

`--<modulnamn>,<alternativnamn>=`

  Du kan använda alternativet för att överskrida ett alternativ i inställningsfilen för en specifik modul. För att till exempel överskrida alternativet use-unsermake för kdemultimedia, skulle du skriva `--kdemultimedia,use-unsermake=false`.

Alla övriga kommandoradsväljare antas vara moduler att uppdatera och bygga. Blanda helst inte ihop bygga och installera.

## Använda &kdesvn-build;

### Förord

Efter du har gått igenom , är det normalt så enkelt att använda &kdesvn-build; som att skriva följande från en terminal:

    &percnt; kdesvn-build

&kdesvn-build; laddar därefter ner &kde;:s källkod, försöker att konfigurera och bygga den, och därefter installera den.

Läs vidare för att upptäcka hur &kdesvn-build; gör detta, och vad du mer kan göra med verktyget.

### Grundläggande funktioner i &kdesvn-build;

#### stöd för qt-copy

&kdesvn-build; strävar efter att bibehålla utmärkt stöd för modulen qt-copy som ingår i &kde;:s &subversion;-arkiv.

qt-copy är en kopia av källkoden för den senaste utgåvan av &Qt;-verktygslådan som används av &kde;. Den innehåller också en uppsättning programfixar och felförbättringsfixar som valfritt kan användas. Programfixarna fungerar fortfarande med &Qt;-biblioteket så att kod skapad genom att använda qt-copy går att köra med det vanliga &Qt;.

De flesta skillnader som krävs för qt-copy hanteras automatiskt av &kdesvn-build;, Dock finns det några skillnader som du kan behöva känna till.

- Normalt läggs värdet av &configure-flags; för en modul till i de allmänna inställningarna för &configure-flags;. Inställningen av &configure-flags; för qt-copy ersätter dock de allmänna inställningarna, eftersom de inte har motsvarande kommandorader.

- &kdesvn-build; definierar automatiskt några extra miljövariabler för att bygga qt-copy, som normalt inte krävs för resten av &kde;.

- qt-copy har också stöd för en valfri uppsättning programfixar som innehåller några felrättningar och optimeringar som ännu inte har kommit med i det officiella &Qt;. För att aktivera dem, sätt alternativet &apply-qt-patches; till true. Efter ändringen har gjorts, kan du behöva köra ``` `--refresh-build` `qt-copy``.

#### Standardflaggor tillagda av &kdesvn-build;

För att spara tid, lägger &kdesvn-build; till några standardsökvägar i miljön åt dig:

- Sökvägen till &kde;- och &Qt;-biblioteken läggs till i variabeln `LD_LIBRARY_PATH` automatiskt. Det betyder att du inte behöver redigera &libpath; för att inkludera dem.

- Sökvägen till program för utvecklingsstöd i &kde; och &Qt; läggs till i variabeln `PATH` automatiskt. Det betyder att du inte behöver redigera &binpath; för att inkludera dem.

- Sökvägen till pkg-config som tillhandahålls av &kde; läggs till i variabeln `PKG_CONFIG_PATH` automatiskt. Det betyder att du inte behöver använda &set-env; för att lägga till dem.

- Inställningen av &kdedir; skickas automatiskt vidare till miljövariabeln `KDEDIR` under byggprocessen. (`KDEDIRS` påverkas inte).

- Inställningen av &qtdir; skickas automatiskt vidare till miljövariabeln `QTDIR` under byggprocessen.

- &kdesvn-build; justerar automatiskt miljön efter behov för att ta hänsyn till inställningen av alternativet &use-unsermake;.

#### Ändra byggprioritet i &kdesvn-build;

Program kan nuförtiden köra med olika prioritetsnivåer på operativsystem, inklusive &Linux; och &BSD;. Det tillåter systemet att tilldela tid för de olika programmen enligt hur viktiga de är.

&kdesvn-build; tilldelar normalt sig själv låg prioritet så att resten av programmen på systemet är opåverkade och kan köra normalt. Genom att använda den här tekniken, använder &kdesvn-build; extra processorkraft när den är tillgänglig.

&kdesvn-build; behåller fortfarande prioritetsnivån nog hög så att det kör innan rutinmässiga bakgrundsprocesser och innan program som donerar processorkraft såsom Seti@Home.

För att ändra &kdesvn-build; så att det använder en högre, eller lägre, prioritetsnivå permanent, måste du justera inställningen av &niceness; i inställningsfilen. Alternativet &niceness; styr hur snällt &kdesvn-build; är mot andra program. Med andra ord, att ha en högre &niceness; ger &kdesvn-build; lägre prioritet. Så för att ge &kdesvn-build; en högre prioritet, reducera &niceness; (och tvärtom). &niceness; kan gå från 0 (inte alls snällt, högsta prioritet) till 20 (supersnällt, lägsta prioritet).

Du kan också tillfälligt ändra prioritet hos &kdesvn-build; genom att använda kommandoradsväljaren &cmd-nice;. Väljarens värde är exakt samma som för &niceness;.

Det är möjligt för vissa program som körs av systemadministratören att ha ett negativt snällhetsvärde, vilket motsvarar ännu högre prioritet för sådana program. Att ange en negativ &niceness; (eller till och med 0) för &kdesvn-build; är inte en god idé, eftersom det inte förbättrar körtiden nämnvärt, men gör att datorn verkar mycket slö om du ändå behöver använda den.

För att köra &kdesvn-build; med snällhetsgrad 15 (en lägre prioritet än normal) skriv:

    &percnt; kdesvn-build --nice=15

Eller kan du redigera inställningsfilen för att göra ändringen permanent:

    &niceness; 15

#### Installera som systemadministratör

Du kanske också vill att &kdesvn-build; ska köra installationen med rättigheter som systemadministratör. Det kan gälla för systeminstallation, som inte rekommenderas. Det är dock också användbart när den rekommenderade installationen som enanvändare av &kde; används. Det beror på att vissa moduler (i synnerhet kdebase) installerar program som tillfälligt behöver förhöjda rättigheter när de kör. De kan inte uppnå dessa rättighetsnivåer om de inte installeras med förhöjda rättigheter.

Du skulle helt enkelt kunna köra &kdesvn-build; som systemadministratör direkt, men det rekommenderas inte, eftersom programmet inte har granskats för den sortens användning. Även om det bör vara säkert att köra programmet på det sättet, är det bättre att undvika att köra som systemadministratör när det är möjligt.

För att hantera detta, tillhandahåller &kdesvn-build; alternativet &make-install-prefix;. Du kan använda alternativet för att ange ett kommando som används för att utföra installationen som en annan användare. Det rekommenderade sättet att använda kommandot är med programmet &sudo;, som kör installationskommandot som systemadministratör.

För att till exempel installera alla moduler genom att använda &sudo;, skulle du kunna göra något liknande:

    global
      &make-install-prefix; sudo
      # Övriga alternativ
    end global

För att använda &make-install-prefix; för bara en enda modul, skulle det här fungera:

    module kdemultimedia
      &make-install-prefix; sudo
    end module

#### Visa förloppet för en byggprocess av en modul

Funktionen är alltid tillgänglig, och automatiskt aktiverad om möjligt. Vad den gör är att visa ett uppskattat byggförlopp medan en modul byggs, på så sätt vet du hur mycket längre det kommer att ta att bygga en modul.

För att använda funktionen måste alternativet &use-unsermake; vara aktiverat för modulen. Alternativet är normalt aktiverat, men vissa moduler stöder inte alternativet, och de förhindras automatiskt från att använda &unsermake;. Om du tror att du har aktiverat &unsermake;, och ändå inte ser en förloppsrapport när modulen byggs, kan det vara möjligt att modulen inte stöder &unsermake;.

### Avancerade funktioner

#### Delvis bygga en modul

Det är möjligt att bara bygga delar av en enda &kde;-modul. Du kanske till exempel bara vill kompilera ett program från en modul. &kdesvn-build; har funktioner som gör det enkelt. Det finns flera komplementära sätt att göra det.

##### Checka ut delar av en modul

Det här är troligen det bästa sättet att göra det. När det fungerar sparar det dig nerladdningstid och diskutrymme. Vad som händer är att &kdesvn-build; bara laddar ner delar av modulen som du anger. Det görs med alternativet &checkout-only; för modulen, som anger en lista med kataloger att ladda ner.

Om du inte redan vet vad som ska laddas ner för en modul, kan det vara en god idé att först bläddra i &subversion;-strukturen för en modul, genom att använda WebSVN.

För att bara hämta &kuser; och &kdat; från kdeadmin, skulle du kunna använda &checkout-only; så här:

    module kdeadmin
      &checkout-only; kuser kdat
    end module

Katalogerna byggs i ordningen de listas i alternativet. Om en av katalogerna behöver någonting annat från modulen för att kunna kompileras, då måste du försäkra dig om att de båda finns med på raden &checkout-only;, och att beroendet som krävs anges före katalogen som behöver det.

Ibland kan ett program också behöva andra kataloger och det är svårt att räkna ut vilka de är, vilket kan kräva ett antal försök med ständiga tillägg av kataloger till alternativet för att räkna ut.

En sista anmärkning om alternativet: Om du ändrar alternativets värde ska du använda ``kdesvn-build` `&cmd-refresh-build;` `modul`` för att försäkra dig om att modulen konfigureras om på ett riktigt sätt. &kdesvn-build; tar aldrig bort befintliga filer om du tar bort ett antal kataloger från alternativet &checkout-only;, eller lägger till alternativet för en modul som redan har checkats ut.

##### Ta bort kataloger från en byggplats

Istället för att begränsa vad som laddas ner, är det möjligt att ladda ner allt men låta byggsystemet utelämna ett antal kataloger när byggprocessen utförs. Det kan vara användbart om en katalog hela tiden ger fel och är onödig för resten av modulen.

Det styrs med alternativet &do-not-compile;. Det fungerar på liknande sätt som &checkout-only; som just beskrivits, på så sätt att det helt enkelt är en lista med kataloger som inte ska kompileras.

Också precis som &checkout-only; kräver alternativet minst att skriptet `configure` körs igen för modulen efter det har ändrats. Det görs med kommandot ``kdesvn-build` `&cmd-reconfigure;` `modul``.

För att ta bort katalogen `dcoppython` från byggprocessen för kdebindings:

    module kdebindings
      &do-not-compile; dcoppython
    end module

##### Kompilera några få kataloger från en fullständig modul

Du kan använda alternativet &inst-apps; för att ange att bara några få kataloger i en hel modul ska byggas (men hela modulen laddas fortfarande ner).

Alternativet är som kombinationen av &checkout-only; och &do-not-compile;: det laddar ner hela modulen som &do-not-compile;, men kompilerar bara katalogerna du anger, som &checkout-only;. På grund av detta är det oftast bättre att helt enkelt använda &checkout-only; istället.

Samma varningar gäller som för de två övriga alternativen. Du måste konfigurera om modulen om du ändrar värde på &inst-apps;.

#### Använda &unsermake;

&unsermake; är ett program som är konstruerat att kopplas in i &kde;:s byggsystem och förbättra byggprocessen genom att ersätta vissa av verktygen som normalt används (inklusive &automake; och &make;). Det är särskilt användbart för de som utför distribuerade kompileringar, eftersom det är mycket snabbare än det normala byggsystemet i den situationen. Dock är &unsermake; snabbare än konkurrenterna även vid när man bygger med en enda dator.

Dessutom innehåller &unsermake; stöd för att uppskatta förloppet hos byggprocessen som pågår. &kdesvn-build; drar fördel av det för att tillhandahålla en byggförloppsindikator vid kompilering. Se också .

&kdesvn-build; tillhandahåller stöd för att använda &unsermake; automatiskt. &kdesvn-build; använder normalt &unsermake; när det är möjligt att använda med en modul.

För att inaktivera stöd för &unsermake; i alla moduler, gör följande:

    global
      use-unsermake false
    end global

För att aktivera stöd för &unsermake; för en enstaka modul, även om det är allmänt inaktiverat, gör följande:

    module modulnamn
      use-unsermake true

      # övriga alternativ anges här...
    end module

&kdesvn-build; uppdaterar automatiskt eller checkar ut &unsermake; när övriga uppdateringar utförs. Om du föredrar att hantera &unsermake; själv, är det möjligt att göra det genom att ställa in värdet för &use-unsermake; till self istället för true.

När det är gjort, försöker &kdesvn-build; fortfarande använda &unsermake;, men utför inte uppdateringar. Du kan antingen ändra &binpath; för att peka på rätt &unsermake;-katalog, eller checka ut och uppdatera &unsermake; själv från dess modul (för närvarande kdenonbeta/unsermake).

#### Stöd för grenar och taggar i &kdesvn-build;

##### Vad är grenar och taggar?

&subversion; stöder hantering av historik för &kde;:s källkod. &kde; använder stödet för att skapa grenar för utveckling, och att ge arkivet en tagg då och då med utgåvan av en ny version.

Till exempel kan utvecklarna av &kmail; arbeta med en ny funktion i en annan gren för att undvika att förstöra versionen som används av de flesta utvecklare. Grenen har pågående utveckling, samtidigt som huvudgrenen (som kallas /trunk) kan ha pågående utveckling.

En tagg är å andra sidan en ögonblicksbild av källkodsarkivet vid en viss tid. Det används av &kde;:s administrationsgrupp för att markera en version av koden som är lämplig för en utgåva och fortfarande tillåta att utvecklare arbetar med koden.

Det finns ingen skillnad i koden mellan grenar, taggar eller huvudgrenen i &subversion;. Det är bara en konvention som används av utvecklarna. Det gör det svårt att stödja grenar och taggar i &kdesvn-build; på ett riktigt sätt. Det finns dock några saker som kan göras.

##### Hur man använder grenar och taggar

Stöd för grenar och taggar hanteras med en uppsättning alternativ, som rör sig från en generell begäran om en version, till en specifik webbadress att ladda ner för avancerade användare.

Det enklaste sättet är att använda alternativen &branch; och &tag;. Du använder helt enkelt alternativet tillsammans med namnet på den önskade grenen eller taggen för en modul, så försöker &kdesvn-build; avgöra lämplig plats i &kde;:s arkiv att ladda ner från. För de flesta moduler i &kde; fungerar det mycket bra.

För att ladda ner kdelibs från &kde; 3.5 (som helt enkelt är känt som grenen 3.5):

    module kdelibs
      branch 3.5
      # övriga alternativ...
    end module

Eller, för att ladda ner kdemultimedia som det var när det gavs ut med &kde; 3.4.3:

    module kdemultimedia
      tag 3.4.3
      # övriga alternativ...
    end module

Du kan ställa in ett allmänt grenvärde, men om du gör det, glöm inte att ange en annan gren för moduler som inte ska använda den allmänna grenen.

##### Stöd för avancerade grenalternativ

&kdesvn-build; stöder två alternativ i situationer då &branch; och &tag; gissar fel angående den riktiga sökvägen: &module-base-path; och &override-url;.

- Alternativet &module-base-path; används för att hjälpa &kdesvn-build; fylla i saknade delar av modulens sökväg. I &kde;:s arkiv är alla sökvägar av formen `svnRoot/module-base-path/modulnamn`. Normalt kan &kdesvn-build; räkna ut den lämpliga delen i mitten själv. När det inte går, kan du använda &module-base-path; så här:

      module qt-copy
        # gren fungerar inte här ännu
        module-base-path branches/qt/3.3
      end module

  Det skulle göra att &kdesvn-build; laddar ner qt-copy från (i det här exemplet) `svn://anonsvn.kde.org/home/kde/branches/qt/3.3/qt-copy`.

- Alternativet &override-url; kräver å andra sidan att du anger den exakta sökvägen att ladda ner från. Det låter dig dock hämta från sökvägar som &kdesvn-build; inte skulle ha någon möjlighet att ladda ner från.

      module qt-copy
        # Ange exakt sökväg att hämta.
        override-url svn://anonsvn.kde.org/home/kde/branches/qt/3.3/qt-copy
      end module

  &kdesvn-build; rör inte eller korrigerar något värde som du anger för &override-url; överhuvudtaget, så om du byter inställningen &svn-server;, kan du också behöva uppdatera det här.

#### Hur &kdesvn-build; försöker försäkra sig om en lyckad byggprocess

##### Automatisk ombyggnad

På grund av diverse problem med &kde;:s byggsystem, där vissa mildras genom att använda &unsermake;, utför &kdesvn-build; automatiskt en serie steg för att automatiskt försöka få en modul att bygga om det misslyckas.

1. Vid första misslyckandet, kör &kdesvn-build; helt enkelt om kommandot `make`. Tro det eller ej, men det fungerar verkligen ibland, och misslyckas annars snabbt om det inte fungerar.

2. Vid andra misslyckandet, försöker &kdesvn-build; konfigurera om modulen och därefter bygga om den. Det fångar ofta situationer där ändring av en byggsystemfil kräver omkonfigurering men byggsystemet inte utförde steget automatiskt.

   Modulens byggkatalog lämnas intakt i detta steg, så förutom inställningssteget, misslyckas det också snabbt om byggprocessen inte kan genomföras.

3. Om modulen ändå misslyckas att byggas, ger &kdesvn-build; upp och går vidare med nästa modul. Det finns dock ändå saker du kan göra för att försöka få modulen att byggas manuellt.

&kdesvn-build; detekterar de flesta fall då byggsystemet behöver konfigureras om och gör automatisk omkonfigurering i dessa fall.

Dessutom, om &kdesvn-build; bygger modulen för första gången, hoppas alla dessa steg över, eftersom en ren ombyggnad oftast inte misslyckas utom om det finns ett verkligt fel.

##### Bygga om en modul manuellt

Om du gör en ändring i en moduls inställningsalternativ, eller om modulens källkod ändras på ett sätt som &kdesvn-build; inte känner igen, kan du behöva bygga om modulen manuellt.

Du kan göra det genom att helt enkelt köra ``kdesvn-build` `--refresh-build` `modul``.

Om du skulle vilja att &kdesvn-build; istället automatiskt bygger om modulen under nästa normala bygguppdatering, kan du skapa en särskild fil. Varje modul har en byggkatalog. Om du skapar en fil som heter `.refresh-me` i en moduls byggkatalog, bygger &kdesvn-build; om modulen nästa gång byggprocessen sker, även om det normalt skulle utföra den snabbare inkrementella byggprocessen.

Normalt är byggkatalogen `~/kdesvn/build/modul/`. Om du ändrar inställning av alternativet &build-dir;, använd den istället för `~/kdesvn/build`.

Bygg om med `.refresh-me` för modulen arts:

    % touch ~/kdesvn/build/arts
    % kdesvn-build

##### Styra ombyggnadsbeteende

Du kanske inte vill att &kdesvn-build; alltid ska försöka bygga om en modul. Du kan inaktivera beteendet permanent genom att ändra alternativet &no-rebuild-on-fail; till värdet true.

Du kan tillfälligt inaktivera beteendet (för ett kommando) genom att använda kommandoradsväljaren &cmd-no-rebuild-on-fail;.

    % kdesvn-build --no-rebuild-on-fail

#### Ändra inställning av miljövariabler

&kdesvn-build; läser inte miljön från anropet som den stora majoriteten av program gör. Istället använder det inställningarna som läses från inställningsfilen för att skapa miljön. Det görs i huvudsak för att försäkra sig om att när du bygger en modul, kan byggprocessen upprepas. Med andra ord, kan &kdesvn-build; bygga en modul även om du glömt vad du ställt in miljövariablerna till i skalet du kör &kdesvn-build; från.

Dock kan du vilja ändra inställning av miljövariabler som &kdesvn-build; inte direkt tillhandahåller ett alternativ för. Det är möjligt med alternativet &set-env;.

I motsats till de flesta alternativ kan det anges flera gånger, och accepterar två värden, åtskilda med mellanslag. Det första är namnet på miljövariabeln som ska sättas, och resten av raden är dess värde.

Ställ in ``DISTRO`=BSD` för alla moduler:

    global
      set-env DISTRO BSD
    end global

#### Återuppta byggprocesser

##### Återuppta en misslyckad eller avbruten byggprocess

Du kan tala om för &kdesvn-build; att börja bygga från en annan modul än det normalt skulle göra. Det kan vara användbart när en uppsättning moduler misslyckades, eller om du avbröt en körning i mitten. Du kan styra det med väljaren &cmd-resume-from;.

Genom att använda &cmd-resume-from; hoppas uppdatering av källkod över.

Återuppta byggprocessen med början på kdebase:

    % kdesvn-build --resume-from=kdebase

##### Ignorera moduler i en byggprocess

På samma sätt som du kan återuppta byggprocessen från en modul, kan du istället välja att uppdatera och bygga normalt, men ignorera en uppsättning moduler.

Du kan göra det med väljaren &cmd-ignore-modules;. Den talar om för &kdesvn-build; att ignorera alla följande moduler på kommandoraden när en uppdatering och byggprocess utförs.

Ignorera extragear/multimedia och kdenonbeta under en fullständig körning:

    % kdesvn-build --ignore-modules extragear/multimedia kdenonbeta

#### Ändra alternativ från kommandoraden

##### Ändra globala alternativ

Du kan ändra uppsättningen alternativ som läses från inställningsfilen direkt från kommandoraden. Ändringen överskrider inställningen i filen, men är bara tillfällig. Den gäller bara så länge den fortfarande är närvarande på kommandoraden.

&kdesvn-build; låter dig ändra alternativ namngivna som alternativnamn genom att ange en väljare på kommandoraden på formen ``--alternativnamn=värde``. &kdesvn-build; känner igen om det inte vet vad alternativet är, ock söker efter namnet i sin lista med alternativnamn. Om det inte känner igen namnet, får du en varning, annars kommer det ihåg värdet du ställde in det till och överskrider en eventuell inställning från filen.

Ställa in alternativet &source-dir; till `/dev/null` för test:

    % kdesvn-build --pretend --källkodskatalog=/dev/null

Inaktivera &unsermake; från kommandoraden. `--refresh-build` används för att tvinga att ändringen av &unsermake; får effekt.

    % kdesvn-build --pretend --refresh-build --use-unsermake=false

##### Ändra modulalternativ

Det är också möjligt att bara ändra alternativ för en viss modul. Syntaxen är liknande: --modul,alternativnamn=värde.

Ändringen överskrider eventuell duplicerad inställning för modulen som hittas i inställningsfilen, och gäller bara när alternativet skickas med på kommandoraden.

Använda en annan byggkatalog för modulen kdeedu:

    % kdesvn-build --kdeedu,byggkatalog=temporärbygg

### Funktioner för &kde;-utvecklare

#### Kontroll av &ssh;-agent

&kdesvn-build; kan försäkra sig om att &kde;-utvecklare som använder &ssh; för att komma åt &kde;:s källkodsarkiv inte av misstag glömmer att lämna verktyget &ssh;-agenten aktiverad. Det kan orsaka att &kdesvn-build; hänger sig för alltid medan det väntar på att utvecklaren ska skriva in lösenordet till &ssh;, så normalt kontrollerar &kdesvn-build; att agenten kör innan det utför uppdateringar av källkoden.

Det görs bara för &kde;-utvecklare som använder &ssh;. Det beror på att inget lösenord krävs för den vanliga anonyma utcheckningen. &subversion; hanterar lösenord för det andra möjliga protokollet för &kde;-utvecklare, https.

Du kanske vill inaktivera kontrollen av &ssh;-agenten, i situationer där &kdesvn-build; detektera närvaron av en agent av misstag. För att inaktivera kontroll av agenten, sätt alternativet `disable-agent-check` till true.

Inaktivera &ssh;-agentkontroll:

    global
      disable-agent-check true
    end global

### Andra funktioner i &kdesvn-build;

#### Ändra mängden utmatning från &kdesvn-build;

&kdesvn-build; har flera väljare för att styra mängden utmatning som skriptet skapar. Hur som helst, kommer fel alltid att matas ut.

- Väljaren `--quiet` (den korta formen är `-q`) gör att &kdesvn-build; i huvudsak är tyst. Bara viktiga meddelanden, varningar eller fel visas. Om tillgängligt visas fortfarande förloppsinformation för byggprocessen.

- Väljaren `--really-quiet` (ingen kortform) gör att &kdesvn-build; bara visar viktiga varningar eller fel när det kör.

- Väljaren `--verbose` (kortformen är `-v`) gör att &kdesvn-build; är mycket detaljerad i utmatningen.

- Väljaren `--debug` är bara till för felsökningssyfte. Den gör att &kdesvn-build; beter sig som om `--verbose` är aktiverad, gör också att kommandon matas ut på terminalen, och visar felsökningsinformation för många funktioner.

#### Färgutmatning

När &kdesvn-build; körs från &konsole; eller en annan terminal, visas normalt färglagd text.

Du kan inaktivera det genom att använda väljaren `--no-color` på kommandoraden, eller ställa in alternativet &colorful-output; i inställningsfilen till false.

Inaktivera färgutmatning i inställningsfilen:

    global
      colorful-output false
    end global

#### Skicka e-post med rapporter om en misslyckad byggprocess

&kdesvn-build; kan skicka en rapport via e-post till en e-postadress du väljer, när en modul misslyckas att bygga av någon orsak. Sättet det fungerar är att du väljer en e-postadress som &kdesvn-build; skickar från, och en e-postadress att underrätta när ett fel uppstår.

&kdesvn-build; skapar då ett brev om det fanns någon modul som misslyckades bygga, i slutet av en fullständig körning. Brevet kommer att innehålla en förkortad fellogg för varje modul. Bara ett brev skickas för varje körning, även om 15 moduler misslyckades byggas.

Funktionen är inte normalt aktiverad. För att aktivera den, måste du ange båda alternativen &email-address; och &email-on-compile-error;. Alternativet `email-address` styr adressen som &kdesvn-build; skickar från, och `email-on-compile-error` styr vart brevet ska skickas.

&kdesvn-build; använder standardmodulen Mail::Mailer i Perl för att skicka e-post. Den ingår i Perl 5.8, och kan installeras med Perl 5.6. Mail::Mailer stöder Sendmail (inklusive e-postprogram som fungerar med Sendmail), inbyggd överföring med SMTP, och qmail.

Skicka e-post från bygg@exempel.se till resultat@exempel.se vid byggfel:

    global
      email-address          bygg@exempel.se    # Från: adress för all kdesvn-build e-post
      email-on-compile-error resultat@exempel.se    # Till: adress för e-post om misslyckad bygg
    end global

#### Ta bort onödiga kataloger efter en byggprocess

Har du ont om diskutrymme men vill ändå köra de allra senaste utcheckningen av &kde;? &kdesvn-build; kan hjälpa dig att reducera diskanvändning medan du bygger &kde; från &subversion;.

Var medveten om att det går åt mycket utrymme för att bygga &kde;. Det finns flera stora delar som använder utrymme när &kdesvn-build; används:

1. Själva utcheckningen av källkoden kan uppta ett försvarligt utrymme. Standardmodulerna upptar ungefär 1.6 Gibyte diskutrymme. Du kan reducera storleken genom att försäkra dig om att du bara bygger så många moduler som du verkligen vill ha. &kdesvn-build; tar inte bort källkod från disken även om du tar bort posten från inställningsfilen, så försäkra dig om att du går till och tar bort oanvända utcheckningar i källkodskatalogen. Observera att källkodsfilerna laddas ner från Internet, och du ska inte ta bort dem om du faktiskt använder dem, åtminstone till du är klar med användning av &kdesvn-build;.

   Om du dessutom har installerat &Qt; från distributionen (och chansen är stor att du har det), behöver du troligen inte installera modulen qt-copy. Det hyvlar av omkring 200 Mibyte från källkodsstorleken på disk.

   En sak att observera är att på grund av sättet som &subversion; fungerar, finns det i själva verket två filer på disk för varje fil som checkas ut från arkivet. &kdesvn-build; har för närvarande inte kod för att försöka minimera källkodsstorleken när källkoden inte används.

2. &kdesvn-build; skapar en separat byggkatalog för att bygga källkoden. Ibland måste &kdesvn-build; kopiera en källkodskatalog för att skapa en falsk byggkatalog. När det sker, används platsbesparande symboliska länkar, så det bör inte vara något krångel med diskutrymme. Byggkatalogen är typiskt mycket större än en moduls källkodskatalog. Byggkatalogen för kdebase är till exempel omkring 455 Mibyte, medan källkoden för kdebase bara är omkring 195 Mibyte.

   Som tur är krävs inte byggkatalogen efter en modul har byggts och installerats med lyckat resultat. &kdesvn-build; kan automatiskt ta bort byggkatalogen efter en modul har installerats. Se exemplen nedan för mer information. Observera att genom att utföra detta steg, blir det omöjligt för &kdesvn-build; att utföra tidsbesparande inkrementella byggprocesser.

3. Till sist krävs diskutrymme för själva installationen av &kde;, som inte körs från byggkatalogen. Det upptar typiskt mindre utrymme än byggkatalogen. Det är dock svårare att få fram exakta siffror.

Hur reducerar man utrymmeskraven för &kde;? Ett sätt är att använda riktiga kompilatorflaggor för att optimera för reducering av utrymme istället för hastighet. Ett annat sätt, som kan ha stor effekt, är att ta bort felsökningsinformation från det färdigbyggda &kde;.

Du bör vara mycket säker på att du vet vad du gör innan du bestämmer dig för att ta bort felsökningsinformation. Att köra den allra senaste programvaran betyder att du kör programvara som potentiellt har mycket större sannolikhet att krascha än stabila utgåvor. Om du kör programvara utan felsökningsinformation kan det vara mycket svårt att skapa en bra felrapport för att få problemet löst, och du måste troligen aktivera felsökning igen för programmet som påverkas och bygga om för att hjälpa en utvecklare att rätta kraschen. Så ta bort felsökningsinformation på egen risk!

Ta bort byggkatalogen efter en modul har installerats. Källkoden behålls fortfarande, och felsökning är aktiverad:

    global
      configure-flags      --enable-debug
      remove-after-install builddir        # Ta bort byggkatalog efter installation
    end global

Ta bort byggkatalogen efter installation, utan felsökningsinformation, med storleksoptimering.

    global
      cxxflags             -Os             # Optimera för storlek
      configure-flags      --disable-debug
      remove-after-install builddir        # Ta bort byggkatalog efter installation
    end global

## &cmake;, byggsystemet för &kde; 4

### Introduktion till &cmake;

Under mars 2006, slog programmet &cmake; ut flera konkurrenter och valdes som byggsystem för &kde; 4, och ersätter systemet baserat på autotools som &kde; har använt från början.

En sida med en introduktion till &cmake; är tillgänglig på &kde; TechBase. Istället för att köra ``make` `-f` `Makefile.cvs``, därefter `configure` och sedan &unsermake; (eller &make;), kör vi helt enkelt &cmake; och därefter &make;.

&kdesvn-build; har initialt stöd för &cmake;. Några funktioner i &kdesvn-build; var i själva verket funktioner i det underliggande byggsystemet, inklusive inst-apps, configure-flags och do-not-compile. När motsvarande funktioner är tillgängliga, tillhandahålls de. Motsvarigheten till alternativet configure-flags är till exempel cmake-options, och alternativet do-not-compile stöds också för &cmake; från och med &kdesvn-build; version 1.6.3.

För vissa alternativ (som inst-apps) finns det dock ingen direkt motsvarighet, och de är inaktiverade. Om jag skulle hitta ett sätt att implementera dem med &cmake; kommer jag att göra det och aktivera alternativet igen. Dock fungerar i stort sett allting på samma sätt.

## Tack till och licenser

&underFDL;