Bug 224065 - kdebase can't build because of kdelibs old version.But the minimum version is installed.
Summary: kdebase can't build because of kdelibs old version.But the minimum version is...
Status: RESOLVED NOT A BUG
Alias: None
Product: kdelibs
Classification: Frameworks and Libraries
Component: general (show other bugs)
Version: unspecified
Platform: Compiled Sources Linux
: NOR normal
Target Milestone: ---
Assignee: kdelibs bugs
URL:
Keywords:
Depends on:
Blocks:
 
Reported: 2010-01-24 18:13 UTC by Antonis Tsiapaliokas
Modified: 2010-01-24 18:30 UTC (History)
1 user (show)

See Also:
Latest Commit:
Version Fixed In:


Attachments

Note You need to log in before you can comment on or make changes to this bug.
Description Antonis Tsiapaliokas 2010-01-24 18:13:06 UTC
Version:           kdelibs and kdebase-branch 4.3.9 (4.4 rc1) (using Devel)
Compiler:          cmake 2.8.0 
OS:                Linux
Installed from:    Compiled sources

hello

This is my first time that i am making a bug report so forgive me if i am making something wrong.My linux distro is slackware 13.I am trying to install kde 4.4 rc1 (4.3.9).I am trying to install the whole system in the home directory of the kde-devl user.I am using the method compile from source.I tried to install kdelibs with the command cmakekde but it failed because it require to be build in a separate directory.So i use the following commands

su kde-devel
password:
cd ~/kdelibs 
mkdir build
cd build
cmake ~/kdelibs -DCMAKE_INSTALL_PREFIX=$KDEDIR \
make -j5
make install

then i am trying to build the kdebase but the following error came out

cd ~/kdebase
cmakekde

kde-devel@darkstar:~/kdebase$ cmakekde
-- Found Qt-Version 4.6.1 (using /home/kde-devel/qt-kde/bin/qmake)
-- Found X11: /usr/lib/libX11.so
-- Adding /home/kde-devel/kde/share/apps/cmake/modules to CMAKE_MODULE_PATH
-- Phonon Version: 4.3.80
-- Found KDE 4.3 include dir: /usr/include
-- Found KDE 4.3 library dir: /usr/lib
-- Found the KDE4 kconfig_compiler preprocessor: /usr/bin/kconfig_compiler
-- Found automoc4: /home/kde-devel/kde/bin/automoc4
CMake Error at /usr/share/apps/cmake/modules/FindKDE4Internal.cmake:1192 (message):
  ERROR: the installed kdelibs version 4.3.4 is too old, at least version
  4.3.60 is required
Call Stack (most recent call first):
  /home/kde-devel/kde/share/cmake-2.8/Modules/FindKDE4.cmake:95 (FIND_PACKAGE)
  CMakeLists.txt:17 (find_package)


-- Configuring incomplete, errors occurred!
make: *** No targets specified and no makefile found.  Stop.

here is the content of the ~/.bashrc

kde-devel@darkstar:~/kde/src$ cat ~/.bashrc                 
## A script to setup some needed variables and functions for KDE 4 development.
## This should normally go in the ~/.bashrc file of your kde-devel user, so    
## that it is executed when a session for that user is started.                
##                                                                             
## If you don't use a separate user, the first section with the                
## environment variables should go into a separate script.                     
                                                                               
prepend() { [ -d "$2" ] && eval $1=\"$2\$\{$1:+':'\$$1\}\" && export $1 ; }    
                                                                               
# Other                                                                        
# you might want to set a full value for PATH rather than prepend'ing, to make 
# sure the your kde3 path isn't in here.                                       
prepend PATH /usr/local/bin                                                    
                                                                               
# Qt                                                                           
# only set Qt related variables if you compiled Qt on your own                 
# (which is discouraged). if you use the distro provided Qt, skip              
# this section. Comment it if necessary.                                       
export QTDIR=$HOME/qt-kde                                                      
                                                                               
prepend PATH $QTDIR/bin                                                        
prepend LD_LIBRARY_PATH $QTDIR/lib                                             
prepend PKG_CONFIG_PATH $QTDIR/lib/pkgconfig                                   
                                                                               
                                                                               
# KDE                                                                          
export KDEDIR=$HOME/kde                                                        
export KDEHOME=$HOME/.kde4                                                     
export KDETMP=/tmp/kde4-$USER                                                  
mkdir -p $KDETMP                                                               
export KDEDIRS=$KDEDIR                                                         
prepend PATH $KDEDIR/bin                                                       
prepend LD_LIBRARY_PATH $KDEDIR/lib                                            
prepend PKG_CONFIG_PATH $KDEDIR/lib/pkgconfig                                  
prepend QT_PLUGIN_PATH $KDEDIR/lib/kde4/plugins                                
                                                                               
export PATH                                                                    
export LD_LIBRARY_PATH                                                         
export PKG_CONFIG_PATH                                                         
export QT_PLUGIN_PATH                                                          
CMAKE_LIBRARY_PATH=/home/kde-devel/kde/lib:$CMAKE_LIBRARY_PATH                 
CMAKE_INCLUDE_PATH=/home/kde-devel/kde/include:$CMAKE_INCLUDE_PATH             
                                                                               
                                                                               
# CMake                                                                        
# Make sure CMake searches the right places.                                   
prepend CMAKE_PREFIX_PATH  $KDEDIR                                             
                                                                               
export CMAKE_PREFIX_PATH                                                       
                                                                               
# DBus                                                                         
# only set DBUS related variables if you compiled dbus on your own             
# (which is really discouraged). if you use the distro provided dbus,          
# skip this variable. Uncomment it if necessary.                               
#export DBUSDIR=$KDEDIR                                                        
#prepend PKG_CONFIG_PATH $DBUSDIR/lib/pkgconfig                                
                                                                               
# only needed on some strange systems for compiling Qt. do not set             
# it unless you have to.                                                       
#export YACC='byacc -d'                                                        
                                                                               
# XDG                                                                          
unset XDG_DATA_DIRS # to avoid seeing kde3 files from /usr                     
unset XDG_CONFIG_DIRS                                                          
                                                                               
# you might want to change these:                                              
export KDE_BUILD=$HOME/kde/build                                               
export KDE_SRC=$HOME/kde/src                                                   
                                                                               
# make the debug output prettier                                               
export KDE_COLOR_DEBUG=1                                                       
export QTEST_COLORED=1                                                         
                                                                               
# Make                                                                         
# Tell many scripts how to switch from source dir to build dir:                
export OBJ_REPLACEMENT="s#$KDE_SRC#$KDE_BUILD#"                                
# Use makeobj instead of make, to automatically switch to the build dir.       
# If you don't have makeobj, install the package named kdesdk-scripts or       
# kdesdk, or check out kdesdk/scripts from svn.                                
alias make=makeobj                                                             
                                                                               
# Uncomment the following lines if DBus does not work. DBus is not             
# working if, when you run `dbus-uuidgen --ensure && qdbus`, you get an error. 
#                                                                              
# alias dbusstart="eval `PATH=$DBUSDIR/bin \                                   
#  $DBUSDIR/bin/dbus-launch --auto-syntax`"                                    
                                                                               
# A function to easily build the current directory of KDE.                     
#                                                                              
# This builds only the sources in the current ~/{src,build}/KDE subdirectory.  
# Usage: cs KDE/kdebase && cmakekde                                            
#   will build/rebuild the sources in ~/src/KDE/kdebase                        
function cmakekde {                                                            
        local srcFolder current                                                
                                                                               
        if test -n "$1"; then                                                  
                # srcFolder is defined via command line argument               
                srcFolder="$1"                                                 
        else                                                                   
                # get srcFolder for current dir                                
                srcFolder=`pwd | sed -e s,$KDE_BUILD,$KDE_SRC,`                
        fi                                                                     
        # we are in the src folder, change to build directory                  
        # Alternatively, we could just use makeobj in the commands below...    
        current=`pwd`                                                          
        if [ "$srcFolder" = "$current" ]; then                                 
                cb                                                             
        fi                                                                     
        # To enable tests, uncomment -DKDE4_BUILD_TESTS=TRUE.                  
        # If you are building to debug or develop, it is reccommended to       
        # uncomment the line -DCMAKE_BUILD_TYPE=debugfull. Be sure to move     
        # it above the -DKDE4_BUILD_TESTS=TRUE line if you leave that one      
        # commented out. You can also change "debugfull" to "debug" to save    
        # disk space.                                                          
        # Some distributions use a suffix for their library directory when     
        # on x86_64 (i.e. /usr/lib64) if so, you have to add -DLIB_SUFFIX=64   
        # for example.                                                         
        # Some distributions use a different home folder for KDE4,             
        # e.g. ~/.kde4. In that case you have to add                           
        # -DKDE_DEFAULT_HOME=.kde4                                             
                                                                               
  /home/kde-devel/kde/bin/cmake "$srcFolder" -DCMAKE_INSTALL_PREFIX=$KDEDIR \  

               # -DKDE4_BUILD_TESTS=TRUE \
               # -DCMAKE_BUILD_TYPE=debugfull
                                             
        # uncomment the following two lines to make builds wait after
        # configuration step, so that the user can check configure output
        #echo "Press <ENTER> to continue..."                             
        #read userinput                                                  
                                                                         
        # Note: To speed up compiling, change 'make -j2' to 'make -jx',  
        #   where x is your number of processors +1                      
        nice make -j5 && make install                                    
        RETURN=$?                                                        
        cs                                                               
        return ${RETURN}                                                 
}                                                                        
                                                                         
# for the lazy ones (aren't we all?)                                     
function cmakekdeall {                                                   
        local folders                                                    
                                                                         
        folders="kdesupport KDE/kdelibs KDE/kdebase \                    
                KDE/kdepimlibs KDE/kdepim KDE/kdesdk \                   
                KDE/kdegraphics KDE/kdevplatform KDE/kdevelop \          
                "                                                        
                # Add others or remove to taste, e.g.                    
                # KDE/kdemultimedia KDE/kdenetwork KDE/kdeutils \        
                                                                         
        cd && cs # go to src root                                        
        svn up $folders                                                  
                                                                         
        for f in $folders; do                                            
            # Remove the "|| return" part if you don't want to           
            # stop the build whenever a single module fails.             
            cs $f && cmakekde || return                                  
        done                                                             
}                                                                        
                                                                         
# A function to easily change to the build directory.                    
# Usage: cb KDE/kdebase                                                  
#   will change to $KDE_BUILD/KDE/kdebase                                
# Usage: cb                                                              
#   will simply go to the build folder if you are currently in a src folder
#   Example:                                                               
#     $ pwd                                                                
#     /home/user/src/KDE/kdebase                                           
#     $ cb && pwd                                                          
#     /home/user/build/KDE/kdebase                                         
function cb {                                                              
        local dest                                                         
                                                                           
        # Make sure build directory exists.                                
        mkdir -p "$KDE_BUILD"                                              
                                                                           
        # command line argument                                            
        if test -n "$1"; then                                              
                cd "$KDE_BUILD/$1"                                         
                return                                                     
        fi                                                                 
        # substitute src dir with build dir                                
        dest=`pwd | sed -e s,$KDE_SRC,$KDE_BUILD,`                         
        if test ! -d "$dest"; then                                         
                # build directory does not exist, create                   
                mkdir -p "$dest"                                           
        fi                                                                 
        cd "$dest"                                                         
}                                                                          
                                                                           
# Change to the source directory.  Same as cb, except this                 
# switches to $KDE_SRC instead of $KDE_BUILD.                              
# Usage: cs KDE/kdebase                                                    
#   will change to $KDE_SRC/KDE/kdebase                                    
# Usage: cs                                                                
#   will simply go to the source folder if you are currently in a build folder
#   Example:                                                                  
#     $ pwd                                                                   
#     /home/user/build/KDE/kdebase                                            
#     $ cs && pwd                                                             
#     /home/user/src/KDE/kdebase                                              
function cs {                                                                 
        local dest current                                                    
                                                                              
        # Make sure source directory exists.                                  
        mkdir -p "$KDE_SRC"                                                   
                                                                              
        # command line argument                                               
        if test -n "$1"; then                                                 
                cd "$KDE_SRC/$1"                                              
        else                                                                  
                # substitute build dir with src dir                           
                dest=`pwd | sed -e s,$KDE_BUILD,$KDE_SRC,`                    
                current=`pwd`                                                 
                if [ "$dest" = "$current" ]; then                             
                        cd "$KDE_SRC"                                         
                else                                                          
                        cd "$dest"                                            
                fi                                                            
        fi                                                                    
}                                                                             
                                                                              
# Add autocompletion to cs function                                           
function _cs_scandir                                                          
{                                                                             
        local base ext                                                        
                                                                              
        base=$1                                                               
        ext=$2                                                                
        if [ -d $base ]; then                                                 
                for d in `ls $base`; do                                       
                        if [ -d $base/$d ]; then                              
                                dirs="$dirs $ext$d/"                          
                        fi                                                    
                done                                                          
        fi                                                                    
}

function _cs()
{
        local cur dirs
        _cs_scandir "$KDE_SRC"
        _cs_scandir "$KDE_SRC/KDE" "KDE/"
        COMPREPLY=()
        cur="${COMP_WORDS[COMP_CWORD]}"
        COMPREPLY=( $(compgen -W "${dirs}" -- ${cur}) )
}

# Remove comment on next line to enable cs autocompletion
#complete -F _cs cs

function start3app {
        mkdir -p /tmp/$USER-kde
        export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/bin/X11:/usr/games
        export LD_LIBRARY_PATH=
        export KDETMP=/tmp/$USER-kde
        export KDEVARTMP=/var/tmp/$USER-kde
        export KDEHOME=$HOME/.kde
        export KDEDIR=/usr
        export KDEDIRS=$KDEDIR
        export DISPLAY=:0
        eval "$@"
        source $HOME/.bashrc   #Reset environment variables again
}


I hope these in formations are enough if not the ask for more :)
Comment 1 Michael Pyne 2010-01-24 18:30:18 UTC
Normally simple build failures should not be reported as a bug unless they are KDE's fault (e.g. can't find file foo.h because foo.h wasn't checked in). Instead if you are having trouble with a build you should email the kde-devel@kde.org mailing list, or you can try the #kde IRC channel on irc.kde.org

In your case it /looks/ like CMake is not being run with CMAKE_PREFIX_PATH set. However I see in your .bashrc that it should be getting set correctly, so I'm not sure what the issue is.

You may want to compare with this installation guide to see if there are any steps you missed by accident: http://hanswchen.wordpress.com/2010/01/20/building-kde-sc-from-svn/