Installing
In this chapter we will discuss the steps necessary to compile and install the IDE:
How to obtain mainly concentrates on downloading the most recent sources from CVS.
requirements lists the programs and libraries which you need installed to successfully compile the IDE.
compilation and installation leads you through all the steps of compilation and installation of the application.
How to obtain a API documentation tells what an API is and how you get such a useful tool for navigating the sources.

How to Obtain
is available in binary form from many different distributions such as SuSE, RedHat and others. These binaries are packed in some convenient format, mostly RPM, for easy installation. To install, follow the standard instructions given in your distribution.
You may as well obtain the sources, compile and install them by yourself. These sources can be found via the project home page at http://www.kdevelop.org or via the ftp site.

Get Daily Snapshots from
If you want be in front of current development, anonymous repository snapshots are available. The module name is kdevelop at :pserver:anonymous@anoncvs.kde.org:/home/kde.

Initial Checkout
To obtain an initial version of you must download it from anonymous . For this so-called checkout operation follow these steps.
We assume you want to put your copy into the kde3src subdirectory of your home directory (~).
# Create the destination directory, if necessary:
~> mkdir kde3src
~> cd kde3src
~/kde3src> cvs -z3 -d :pserver:anonymous@anoncvs.kde.org:/home/kde co kdevelop
~/kde3src> cd kdevelop
Once you have successfully checked out your version, you may keep up with the changes using the update procedure shown in the next section.
Keep the server load low. Please do not checkout every time you want to keep your up to date! Use CVS update for this purpose.
Now you may compile your version as shown in the Compilation and Installation section.

Keeping Your Copy up to Date
After you checked out (and successfully compiled) from CVS as shown above, you'll want to keep it up to date in order to get all the patches. Follow these steps. (We again assume you have put your copy into the kde3src directory.)
Note the up (= update) command instead of the co (which stands for checkout).
~> cd kde3src
~/kde3src> cvs -z3 -d :pserver:anonymous@anoncvs.kde.org:/home/kde up kdevelop
~/kde3src> cd kdevelop
Keep an eye on the messages produces during the update sequence. The exact steps in the compilation sequence depend on this.
Now you can compile a new version as shown in the Special compilation considerations chapter.

Requirements
In order to successfully compile and use , you need the following programs and libraries. They are available on most platforms as distribution packages and thereby can be installed easily.

Required:
gcc/g++ ≥ 2.95.3 (or compatible)
Available from gcc.gnu.org
make (or compatible)
Available from www.gnu.org/software/make
5.004 (or higher)
Available from www.perl.com
autoconf ≥ 2.52 (or higher)
Available from www.gnu.org/software/autoconf
automake ≥ 1.6 (or higher)
Available from www.gnu.org/software/automake
flex 2.5.4 (or higher)
Available from www.gnu.org/software/flex
≥ 3.0.3 (or higher)
Available from www.trolltech.com/products/qt
KDE ≥ 3.0.2 (or higher)
Available from www.kde.org

Optional:
The ctags source navigation tool, from http://ctags.sourceforge.net, which enables you fast access to declarations and definitions by a few simple clicks on a name in the editor.
dot, a graphics language compiler, from http:/www.graphviz.org. This tool is needed in conjunction with below if you want to have class relationships graphically displayed (which is highly recommended).
The documentation tool, from http://www.doxygen.org if you want to generate concise and powerful API documentation from your projects.
valgrind from http://developer.kde.org/~sewardj/ helps you to find memory management problems in your applications.
CVS from http://www.cvshome.org if you want to use the versioning system.
Any other compiler and/or tool in case you want to develop for another language/platform than C++/ or use some special facility.
You can, to a certain extent, circumvent the need for ≥ 2.52 and ≥ 1.6. Just remove the admin directory in your installation directory and type
(your-kdevelop-directory)> ln -s $KDEDIR/share/apps/kdelibs/admin admin
at the console. This causes to use the standard settings in the admin directory instead.
Be careful not to mix versions. Always link to the same version your library was compiled. Otherwise you will most likely experience very strange behaviours.

Compilation and Installation
Once all requirements are met, you are ready to compile and install . This chapter will discuss the necessary steps to do so.
Preliminary Steps tells you about setting up a proper environment.
Compile deals with obtaining the sources from , how to prepare them for the installation process, and finally shows the steps necessary to compile and install .
Some Notes on configure Options tells you how to run if it has been installed in a location other than the directory.

Preliminary Steps
Before entering the compile sequence you must make sure all libraries and tools are available to the make system. To accomplish this some environment variables need to be properly set. The actual steps to be performed depend on the console shell you use.
To avoid typing in all the statements that set the necessary environment variables every time you want to compile, you should put them into your .bashrc or .cshrc file. This way the environment variables will be properly set every time you start the shell.

Setting the Environment for the bash Shell
If you use the bash shell add the following lines:
export KDEDIR=(path to your KDE installation)
export QTDIR=(path to your Qt library)
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

Setting the Environment for the tcsh Shell
If you use the tcsh shell add the following lines:
setenv KDEDIR (path to your KDE installation)
setenv QTDIR (path to your Qt library)
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

Compile
In the following discussion we assume that you have put your sources in the ~/kde3src/kdevelop directory.

Special Compilation Considerations
In case you use a snapshot from the initial compilation steps depend on whether you just did a complete checkout or only updated the source.

After a CVS Checkout
You must initialize the make system after a fresh checkout. The same is true every time you need to start over from scratch. Type:
~/kde3src/kdevelop> make -f admin/Makefile.common cvs-clean
and then all of the following steps.
You might need access to the repository for the clean-up if any corrupted or missing files must be reconstructed.
The cvs-clean command will remove every file not in from the directory! Make sure to back up any valuable information before you issue this clean-up command.

After a CVS Update
The next step depends on the output of the update sequence. If you got something like (there may be a U or a P marker in the leftmost column, both denoting the file has been changed):

U /some_directory_path/Makefile.am

or if you just did a full checkout, you must enter:
~/kde3src/kdevelop> make -f Makefile.cvs
before you proceed with all of the following steps.

Basic make Command Sequence
Once the basic make system is set up you must decide which type of the system you want to use. This is done in the following configure step which builds the actual Makefiles the make command will use.
You may drop the --prefix option in the following configure command lines if you want be installed in the default directory. See the Some notes on configure options chapter for this.

A Debug-Compiled Version
If you want to keep track of what your application does at run-time you may build a debug-compiled version. Just command configure to do so:
~/kde3src/kdevelop> ./configure --enable-debug=full --prefix=(where-your-kde3-is)

A Release-Compiled Version
If you only want to use as-is a (smaller and faster running) release version suffices. configure defaults to this.
~/kde3src/kdevelop> ./configure --prefix=(where-your-kde3-is)
If you want to build your own API documentation for you must include yet another option in the configure command:
~/kde3src/kdevelop> ./configure --(options-as-above) \
--with-kdelibsdoxy-dir=$KDEDIR/share/doc/HTML/en/kdelibs-apidocs

Make and Install
configure will check the system and build some Makefiles according to what it found. The make command will use the main Makefile by default. Thus
~/kde3src/kdevelop> make
suffices. If necessary, now gain root user rights using the command
~/kde3src/kdevelop> su
and entering the root password. Then install the application:
~/kde3src/kdevelop> make install
That's all. If you installed in the default directory you may now run the IDE. Otherwise some additional steps will be necessary as shown in the Non-default installation directory section below.
In fact there usually will have been three -based applications installed:
The IDE — this is the place where you will usually work.
The stand-alone Assistant documentation browser — isolates all the powerful documentation facilities of the IDE in a separate tool. This comes in handy when you want to look up some programming documentation but do not want to start the full IDE.
The Designer — enhances the User Interface Designer by specific elements and integrates nicely in the IDE.

Some Notes on configure Options

Non-default Installation Directory
By default configure prepares the IDE to be installed in the default directory. This is necessary because assumes direct access to some tools and parts which reside there. If want to use your own installation directory, you must tell configure this by the --prefix option:
~/kde3src/kdevelop> ./configure --prefix=(where-your-kde3-is)
There is a caveat if you do so. You must provide a means for to access the needed tools and parts in the directory when running. (You can still use the IDE without doing so, but with very restrained capabilities.)
Call up a shell and have the following commands executed before you start at the shell prompt.
Take care to use the plural: It is KDEDIRS, not just KDEDIR)
~> export KDEDIRS=/usr/local/kde:/opt/kde3
~> kbuildsycoca
(Now start :)
~> kdevelop
The KDEDIRS environment variable must be set to the list of active directories in your system. We use
/usr/local/kde:/opt/kde3
as an example only.
The /usr/local/kde directory may for instance contain an incomplete version you compiled for debug purposes, and the /opt/kde3 directory may in addition contain the standard version from your distribution that is used for everyday work.
In a tcsh shell you must set the environment variables using:
~> setenv KDEDIRS /usr/local/kde:/opt/kde3
The kbuildsycoca command (build system control cache) looks around for libraries and caches their location and version, so that can find them. The caveat is that it takes noticeable time—and it has to be run any time you call up the shell to start from a non-default directory. You may want to put the above commands into a shell script to reduce the typing effort.
(You could as well put the lines in your .bashrc or .cshrc file, but this is not advisable as kbuildsycoca will then be run any time you call up the shell.)
The kbuildsycoca command does not run from within the root. You must call it from a non-root user. (But is not a very good idea after all to do software development from within the root!)

How to Obtain a API Documentation
API is the short form of Application Program Interface. Actually such an API cotains a series of descriptions ( calling conventions) by which an application program can access the operating system and other services. In our context, however, a broader definition was adopted. The API of a or application is an abstract of the classes and methods interfaces, a synopsis to be used like a dictionary to navigate the sources.
There is a version of the most current API available at the KDevelop-Home website. It will be automatically updated every 24 hours so you can keep up.
Alas, this version is best used read-only over the internet. If you do not always have internet access you may as well build your own API documentation from the sources. To do so, you must tell the automake system where to find the KDELIBS API in your system. This is accomplished by the special option --with-kdelibsdoxy-dir in the configure command when you prepare to compile the sources:
~/kde3src/kdevelop> ./configure --(options-as-usual) \
--with-kdelibsdoxy-dir=$KDEDIR/share/doc/HTML/en/kdelibs-apidocs
(make will replace the global $KDEDIR variable with the actual directory setting recorded therein.) Then issue a make command as usual. After the IDE has been built you have the option to build the API as well. For this you must issue
~/kde3src/kdevelop> make apidocs
This will build a Doxyfile in your base directory which in turn will be processed by the Doxygen application to build quite a lot of .html API files. When this rather lengthy API building process (may last more than an hour on a slow system) finally comes to an end, you must install the API just like you have to install the IDE itself. If necessary obtain superuser rights by
~/kde3src/kdevelop> su
and entering the root password. Then install the API files:
~/kde3src/kdevelop> make install-apidox
Once this is done, make will inform you about the directory where you can finally look at the API documentation's contents. Note this address, you can use it from as well as from inside , in case you have set up the sources themselves as a project to work on.
You will most probably see a lot of warning and/or error messages during the API build run by Doxygen. It is best to ignore them, they are of interest to the developers only. If the API generation ever comes to a successful end, the .html API files will be usable.