Untitled

#!/bin/bash

##############################################################################
##
##  ScanGear MP for Linux
##  Copyright CANON INC. 2007-2013
##  All Rights Reserved.
##
##  This program is free software; you can redistribute it and/or modify
##  it under the terms of the GNU General Public License as published by
##  the Free Software Foundation; version 2 of the License.
##
##  This program is distributed in the hope that it will be useful,
##  but WITHOUT ANY WARRANTY; without even the implied warranty of
##  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
##  GNU General Public License for more details.
##
##  You should have received a copy of the GNU General Public License
##  along with this program; if not, write to the Free Software
##  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
##
##############################################################################

C_version="2.20-1"
C_copyright_end="2013"
C_default_system="deb"

L_INST_COM_01_01="Command executed = %s\n"

L_INST_COM_01_02="An error occurred. The package management system cannot be identified.\n"
L_INST_COM_01_03="An error occurred. A necessary package could not be found in the proper location.\n"
L_INST_COM_01_04="Installation has been completed.\n"
L_INST_COM_01_05="An error occurred. Your environment cannot be identified as 32-bit or 64-bit.\nTry to install again by using the following command.\n"
L_INST_COM_01_06="An error occurred. The specified environment differs from your environment.\nTry to install again by using the following command.\n"

L_INST_COM_02_01="Usage: %s\n"

L_INST_COM_02_02="Uninstallation has been completed.\n"

L_INST_COM_03_01="[Package]\n"


L_INST_SCN_00_01="ScanGear MP"
L_INST_SCN_00_02="Version %s"
L_INST_SCN_00_03="Copyright CANON INC. %s-%s"
L_INST_SCN_00_04="All Rights Reserved."


C_main_module="scangearmp"
C_copyright_start="2007"

#################################################################
#### C_function name define
#################################################################
C_function01="S_FUNC_show_inst_complete"
C_function02="S_FUNC_no_action"
C_function03="S_FUNC_show_copyright"

#################################################################
#### Show "install complete" message  $1:L_INST_COM_01_04
#### C_function01
#################################################################
S_FUNC_show_inst_complete(){
        printf "$1"
}

#################################################################
#### No action, case scanner
#### C_function02
#################################################################
S_FUNC_no_action(){
        echo -n ""
}

#################################################################
#### Show the copyright  $1:version $2:copyright_end
#### C_function03
#################################################################
S_FUNC_show_copyright()
{
#       s_copyright1="ScanGear MP Ver.$1 for Linux"
#       s_copyright2="Copyright CANON INC. 2007-2011"
#       s_copyright3="All Rights Reserved."

#       echo $s_copyright1; echo $s_copyright2; echo $s_copyright3

        printf "$L_INST_SCN_00_01\n"
        printf "$L_INST_SCN_00_02\n" $1
        printf "$L_INST_SCN_00_03\n" $C_copyright_start $C_copyright_end
        printf "$L_INST_SCN_00_04\n"
}

C_ERR_CODE="128"
C_big="50"
C_equal="40"
C_small="30"

C_common="common"
C_system=""
C_arch=""
C_arch32=""
C_arch64=""

C_err="no_error"
C_err_unknown="err_unknown"
C_err_mismatch="err_mismatch"
C_err_usage="err_usage"

C_install_script_fname="install.sh"
C_config_path_rpm="/usr/local/bin"
C_config_path_deb="/usr/bin"

C_copyrightb="=================================================="

C_arg_inst="[ --bit32 | --bit64 ]"
C_arg_pkg="[ --uninstall | --version ]"

C_FUNC_show_and_exec()
{
        printf "$L_INST_COM_01_01" "$1"
        $1
}

C_FUNC_version_comp()
{
        local c_tmpstr=""
        local c_ver1=""
        local c_ver2=""
        local c_rela1=""
        local c_reln1=""
        local c_rela2=""
        local c_reln2=""

        C_FUNC_makelist()
        {
                echo $1
                echo $2
        }

        ## version compare ##
        # ex. 3.10->310, 1.30->130 #
        c_tmpstr=`echo ${1%%-*}`
        c_ver1=`echo ${c_tmpstr%%.*}``echo ${c_tmpstr##*.}`
        c_tmpstr=`echo ${2%%-*}`
        c_ver2=`echo ${c_tmpstr%%.*}``echo ${c_tmpstr##*.}`

        # ex. 310 > 300  #
        if [ "$c_ver1" -gt "$c_ver2" ]; then
                return $C_big
        elif [ "$c_ver1" -lt "$c_ver2" ]; then
                return $C_small
        fi

        ## release compare ##
        # ex. a13->[a][13], 2->[][2] #
        c_tmpstr=`echo ${1##*-}`
        c_rela1=`echo ${c_tmpstr%%[0-9]*}`
        c_reln1=`echo ${c_tmpstr##*[a-z]}`
        c_tmpstr=`echo ${2##*-}`
        c_rela2=`echo ${c_tmpstr%%[0-9]*}`
        c_reln2=`echo ${c_tmpstr##*[a-z]}`

        # ex. [a][13] < [][2] #
        if [ -z "$c_rela1" ] && [ -n "$c_rela2" ]; then
                return $C_big
        elif [ -n "$c_rela1" ] && [ -z "$c_rela2" ]; then
                return $C_small
        fi

        # ex. [a][2] < [b][1] #
        if [ -n "$c_rela1" ] && [ "$c_rela1" != "$c_rela2" ]; then
                list=`C_FUNC_makelist $c_rela1 $c_rela2 | sort`
                for c_tmpstr in $list; do
                        if [ "$c_tmpstr" = "$c_rela1" ]; then
                                return $C_small
                        else
                                return $C_big
                        fi
                done
        fi

        # ex. [a][2] > [a][1], [b][9] < [b][10] #
        if [ "$c_reln1" -gt "$c_reln2" ]; then
                return $C_big
        elif [ "$c_reln1" -lt "$c_reln2" ];then
                return $C_small
        else
                return $C_equal
        fi
}

C_FUNC_get_system()
{
        local c_system_rpm=""
        local c_system_deb=""

        ## Judge is the distribution supporting rpm? ##
        rpm --version 1> /dev/null 2>&1
        c_system_rpm=$?

        ## Judge is the distribution supporting dpkg(debian)? ##
        dpkg --version 1> /dev/null 2>&1
        c_system_deb=$?

        ## rpm error and deb error is error ##
        if [ $c_system_rpm != 0 -a $c_system_deb != 0 ]; then
                return $C_ERR_CODE
        elif [ $c_system_rpm = 0 -a $c_system_deb = 0 ]; then
                C_system=$C_default_system
        else
                if test $c_system_rpm -eq 0; then
                        C_system="rpm"
                else
                        C_system="deb"
                fi
        fi

        if [ $C_system = "rpm" ]; then
                C_arch32="i386"
                C_arch64="x86_64"
        else
                C_arch32="i386"
                C_arch64="amd64"
        fi

        return 0
}

C_FUNC_get_bitconf()
{
        local c_bit_conf=""
        local c_sudo_command=""
        local c_arg1=$1

        if [ $C_system = "deb" ]; then
                c_sudo_command="sudo "
        fi

        getconf LONG_BIT 1> /dev/null 2>&1
        if [ $? -eq 0 ]; then
                c_bit_conf=`getconf LONG_BIT`
        else
                c_bit_conf=""
        fi

        if [ -z $C_arch ]; then
                # No argment and getconf=32|64 -> continue #
                if [ -z $c_bit_conf ]; then
                        if [ -z $c_arg1 ]; then
                                C_err=$C_err_unknown
                        elif [ $c_arg1 = "version" ]; then
                                C_arch="*"
                        fi
                elif [ $c_bit_conf = "32" ]; then
                        C_arch=$C_arch32
                elif [ $c_bit_conf = "64" ]; then
                        C_arch=$C_arch64
                else
                        C_err=$C_err_unknown
                fi
        else
                if [ $C_arch = "32" ]; then
                        # --bit32 and getconf=error -> continue #
                        if [ -z $c_bit_conf ]; then
                                C_arch=$C_arch32
                        elif [ $c_bit_conf = "32" ]; then
                                C_arch=$C_arch32
                        else
                                C_err=$C_err_mismatch
                        fi
                elif [ $C_arch = "64" ]; then
                        # --bit64 and getconf=error -> continue #
                        if [ -z $c_bit_conf ]; then
                                C_arch=$C_arch64
                        elif [ $c_bit_conf = "64" ]; then
                                C_arch=$C_arch64
                        else
                                C_err=$C_err_mismatch
                        fi
                fi
        fi

        if [ $C_err = $C_err_mismatch ]; then
                printf "$L_INST_COM_01_06"
                printf "\n  ${c_sudo_command}${0}\n\n"
                return $C_ERR_CODE
        elif [ $C_err = $C_err_unknown ]; then
                printf "$L_INST_COM_01_05"
                printf "\n  ${c_sudo_command}${0} ${C_arg_inst}\n\n"
                return $C_ERR_CODE
        fi

        return 0
}

C_FUNC_localize()
{
        local lc_file_dir=$1

        ## Get current LANG information ##
        local current_lang=`echo $LANG | tr '[:upper:]' '[:lower:]'`

        ## Get printer or scanner ##
        local driver=""
        if [ $C_main_module = "cnijfilter" ]; then
                driver="printer"
        else
                driver="scanner"
        fi

        ## Get localize file name ##
        local lc_file="nolocalize"
        case "${current_lang##*.}" in
                utf8 | utf-8)
                        case "${current_lang%%.*}" in
                                ja_jp)
                                        lc_file="${driver}_ja_utf8.lc"
                                        ;;
                                fr_fr)
                                        lc_file="${driver}_fr_utf8.lc"
                                        ;;
                                zh_cn)
                                        lc_file="${driver}_zh_utf8.lc"
                                        ;;
                        esac
                        ;;
        esac

        ## Set localize file ##
        if [ $lc_file != "nolocalize" ]; then
                if [ -f ${lc_file_dir}/${lc_file} ]; then
                        source ${lc_file_dir}/${lc_file}
                fi
        fi

        return 0
}

######################################################
#### _ _ E x e c u t e _ I n s t a l l . s h  _ _ ####
######################################################
if [ ${0##*/} = $C_install_script_fname ]; then

        #################################################################
        #### _ _ B o t h _ P a c k a g e _ C o m m o n _ F l o w _ _ ####
        #################################################################

        C_argment=$1

    ################
        ### Localize ###
    ################
    C_local_path_inst="`echo $(dirname $0)`/resources"
        C_FUNC_localize "$C_local_path_inst"

        ########################
        ## Show the copyright ##
        ########################
        C_FUNC_get_system
        if [ $? -eq 0 ]; then
                if [ $C_system = "rpm" ]; then
                        ##  Check permission by root ##
                        if test `id -un` != "root"; then
                                su -c "$0 $*"
                                exit
                        fi
                else
                        sudo echo > /dev/null
                        if [ $? -ne 0 ]; then
                                exit
                        fi
                fi
        fi
        echo $C_copyrightb; echo
        $C_function03 "${C_version%%-*}"
        echo ; echo $C_copyrightb

        #########################
        ### Check the argment ###
        #########################
        if [ $# -eq 1 ]; then
                if  [ $C_argment = "--bit32" ]; then
                        C_arch="32"
                elif [ $C_argment = "--bit64" ]; then
                        C_arch="64"
                else
                        C_err=$C_err_usage
                fi
        elif [ $# -ne 0 ]; then
                C_err=$C_err_usage
        fi

        if [ $C_err = $C_err_usage ]; then
                printf "$L_INST_COM_02_01" "${0##*/} $C_arg_inst"
                exit
        fi

    #################################
        ### Judge distribution system ###
    #################################

        C_FUNC_get_system
        if [ $? -ne 0 ]; then
                printf "$L_INST_COM_01_02"
                exit
        fi

    #########################
        ### Judge 32bit/64bit ###
    #########################

        C_FUNC_get_bitconf
        if [ $? -ne 0 ]; then
                exit
        fi

    ############################
        ### Check file structure ###
    ############################

        ## Get full path of script and packages ##
        C_pkg_path=`echo $(dirname $0)`/packages
        if [ ! -d $C_pkg_path ]; then
                printf "$L_INST_COM_01_03"
                exit
        fi

        ## Count total files and check the filename ##
        C_file_cnt=0
        C_files=$C_pkg_path/*${C_arch}*
        for filename in $C_files; do
                if [ $filename != $C_pkg_path ]; then
                        # Count number of C_files           #
                        C_file_cnt=`expr $C_file_cnt + 1`

                        # Get only file name              #
                        C_onlyfname=`echo ${filename##*/}`
                        # Check the extension, and the filename for module #
                        if [ `echo ${C_onlyfname##*.}` != $C_system -o `echo ${C_onlyfname%%-*}` != $C_main_module ]; then
                                printf "$L_INST_COM_01_03"
                                exit
                        fi

                        # Get device name(ex.mx860series) #
                        C_tmpstr=`echo ${C_onlyfname##$C_main_module-}`
                        if [ $C_system = "rpm" ]; then
                                if [ `echo ${C_tmpstr%%-$C_version*}` != $C_common ]; then
                                        C_device=`echo ${C_tmpstr%%-$C_version*}`
                                fi
                        else
                                if [ `echo ${C_tmpstr%%_$C_version*}` != $C_common ]; then
                                        C_device=`echo ${C_tmpstr%%_$C_version*}`
                                fi
                        fi
                fi
        done

        ## Check number of C_files ##
        if [ $C_file_cnt -ne 2 ]; then
                printf "$L_INST_COM_01_03"
                exit
        fi

        ## Recheck package names ##
        C_pkgname_common=$C_main_module-$C_common
        C_pkgname_depend=$C_main_module-$C_device
        if [ $C_system = "rpm" ]; then
                C_fpath_common=$C_pkg_path/$C_pkgname_common-$C_version.$C_arch.$C_system
                C_fpath_depend=$C_pkg_path/$C_pkgname_depend-$C_version.$C_arch.$C_system
        else
                C_fpath_common=$C_pkg_path/${C_pkgname_common}_${C_version}_$C_arch.$C_system
                C_fpath_depend=$C_pkg_path/${C_pkgname_depend}_${C_version}_$C_arch.$C_system
        fi

        ## Check having common and depend package files ##
        if [ ! -f $C_fpath_common ] || [ ! -f $C_fpath_depend ]; then
                printf "$L_INST_COM_01_03"
                exit
        fi

        #####################################################################
        #### _ _ P a c k a g e _ S y s t e m _ D e p e n d _ F l o w _ _ ####
        #####################################################################

        C_FUNC_rpm_install_process()
        {
                local c_fpath_pkg_name=$1
                local c_pkg_name=$2
                local c_exec_update=1
                local c_installed_pkg=""

                ## result -> 0:Package installed, 1:Package not installed ##
                c_installed_pkg=`rpm -q $c_pkg_name`
                if [ $? -eq 0 ]; then
                        c_installed_pkg_ver=`echo ${c_installed_pkg##$c_pkg_name-}`
                        c_installed_pkg_ver=`echo ${c_installed_pkg_ver%%.$C_arch32}`
                        c_installed_pkg_ver=`echo ${c_installed_pkg_ver%%.$C_arch64}`
                        C_FUNC_version_comp $c_installed_pkg_ver $C_version
                        if [ $? -ne $C_small ]; then
                                c_exec_update=0
                        fi
                fi

                if [ $c_exec_update -eq 1 ]; then
                        C_FUNC_show_and_exec "rpm -Uvh $c_fpath_pkg_name"
                        if [ $? -ne 0 ]; then
                                return $C_ERR_CODE
                        fi
                else
                        C_FUNC_show_and_exec "rpm --test -U $c_fpath_pkg_name"
                fi

                return 0
        }

        C_FUNC_deb_install_process()
        {
                local c_fpath_pkg_name=$1

                ## result -> 0:Install process complete, 1:Install process depend error ##
                C_FUNC_show_and_exec "sudo dpkg -iG $c_fpath_pkg_name"
                if [ $? != 0 ]; then
                        return $C_ERR_CODE
                fi

                return 0
        }

        ## Make Package-config script, after Check Newer version config script is installed already ##
        C_FUNC_make_pkgconfig()
        {
                local c_pkgconfig_fname=$1
                local c_script_path=$2
                local c_sudo_command=$3
                local c_pkgconfig_fpath="$c_script_path/$c_pkgconfig_fname"
                local c_config_path=""

                if [ ! -d /usr ]; then
                        $c_sudo_command mkdir /usr
                fi
                if [ $2 = "rpm" ]; then
                        if [ ! -d /usr/local ]; then
                                mkdir /usr/local
                        fi
                        c_config_path=$C_config_path_rpm
                else
                        c_config_path=$C_config_path_deb
                fi
                if [ ! -d $c_config_path ]; then
                        $c_sudo_command mkdir $c_config_path
                fi

                $c_sudo_command cp -af $(dirname $0)/$C_install_script_fname $c_pkgconfig_fpath

                ## Change file permission to same install.sh ##
                $c_sudo_command chmod 755 $c_pkgconfig_fpath
                $c_sudo_command chown root $c_pkgconfig_fpath
                $c_sudo_command chgrp root $c_pkgconfig_fpath
        }

        ## Copy Localize-file, after making pkeconfig script ##
        C_FUNC_copy_lcfile()
        {
                local c_lcfile_srcpath=$1
                local c_lcfile_dstname=$2
                local c_sudo_command=$3
                local c_lcfile_dstpath=""

                if [ ! -d /usr ]; then
                        $c_sudo_command mkdir /usr
                fi
                if [ $C_system = "rpm" ]; then
                        if [ ! -d /usr/local ]; then
                                mkdir /usr/local
                        fi
                        if [ ! -d /usr/local/share ]; then
                                mkdir /usr/local/share
                        fi
                        c_lcfile_dstpath="/usr/local/share"
                else
                        if [ ! -d /usr/share ]; then
                                $c_sudo_command mkdir /usr/share
                        fi
                        c_lcfile_dstpath="/usr/share"
                fi

                $c_sudo_command rm -rf $c_lcfile_dstpath/$c_lcfile_dstname
                $c_sudo_command mkdir $c_lcfile_dstpath/$c_lcfile_dstname

                $c_sudo_command cp -a $c_lcfile_srcpath/*.lc $c_lcfile_dstpath/$c_lcfile_dstname/
        }

        if [ $C_system = "rpm" ]; then
                C_install_process="C_FUNC_rpm_install_process"
                C_uninstall_command="rpm -e"
                C_script_path=$C_config_path_rpm
                C_sudo_command=""
        else
                C_install_process="C_FUNC_deb_install_process"
                C_uninstall_command="sudo dpkg -P"
                C_script_path=$C_config_path_deb
                C_sudo_command="sudo"
        fi

        ## Common-Package install process ##
        $C_install_process $C_fpath_common $C_main_module-$C_common
        if [ $? -ne 0 ]; then
                if [ $C_system = "deb" ]; then
                        C_FUNC_show_and_exec "$C_uninstall_command $C_pkgname_common"
                fi
                exit
        fi

        ## Depend-Package install process ##
        $C_install_process $C_fpath_depend $C_main_module-$C_device
        if [ $? -ne 0 ]; then
                if [ $C_system = "deb" ]; then
                        C_FUNC_show_and_exec "$C_uninstall_command $C_pkgname_depend"
                fi
                C_FUNC_show_and_exec "$C_uninstall_command $C_pkgname_common"
                exit
        fi

        C_pkgconfig_fname=$C_main_module-$C_device-pkgconfig.sh
        C_pkgconfig_dname=${C_pkgconfig_fname%%\.sh}
        $C_pkgconfig_fname --pkgconfig 1> /dev/null 2>&1
        if [ $? -ne 0 ]; then
                C_FUNC_make_pkgconfig $C_pkgconfig_fname $C_script_path $C_sudo_command
                C_FUNC_copy_lcfile $C_local_path_inst $C_pkgconfig_dname $C_sudo_command
        else
                C_installed_config_ver=`$C_pkgconfig_fname --pkgconfig`
                C_FUNC_version_comp $C_installed_config_ver $C_version
                if [ $? -lt $C_equal ]; then
                        $C_sudo_command rm -rf $C_script_path/$C_pkgconfig_fname
                        C_FUNC_make_pkgconfig $C_pkgconfig_fname $C_script_path $C_sudo_command
                        C_FUNC_copy_lcfile $C_local_path_inst $C_pkgconfig_dname $C_sudo_command
                fi
        fi

        $C_function01 "$L_INST_COM_01_04" "$C_device" "$C_system"

##########################################################
#### _ _ E x e c u t e _ P k g c o n f i g . s h  _ _ ####
##########################################################
else
        C_argment=$1

    #################################
        ### Judge distribution system ###
    #################################
        C_FUNC_get_system
        if [ $? -ne 0 ]; then
                printf "$L_INST_COM_01_02"
                exit
        fi

        C_intermediate=${0##*$C_main_module-}
        C_device=${C_intermediate%%-*}

    ################
        ### Localize ###
    ################
        if [ $C_system = "rpm" ]; then
                C_local_path_pkgconf="/usr/local/share/${C_main_module}-${C_device}-pkgconfig"
        else
                C_local_path_pkgconf="/usr/share/${C_main_module}-${C_device}-pkgconfig"
        fi
        C_FUNC_localize "$C_local_path_pkgconf"

        ## Check the argment ##
        if [ $# -ne 1 ]; then
                C_err=$C_err_usage
        elif [ $C_argment != "--version" ] && [ $C_argment != "--uninstall" ] && [ $C_argment != "--pkgconfig" ]; then
                C_err=$C_err_usage
        fi

        if [ $C_err = $C_err_usage ]; then
                printf "$L_INST_COM_02_01" "${0##*/} $C_arg_pkg"
                exit
        fi

        ########################
        ### Unistall process ###
        ########################
        if [ $C_argment = "--uninstall" ]; then

                C_FUNC_rpm_uninstall_process()
                {
                        rpm -q $1 1> /dev/null 2>&1
                        ## result -> 0:Package installed, 1:Package not installed ##
                        if [ $? -eq 0 ]; then
                                # uninstall #
                                C_FUNC_show_and_exec "rpm -e $1"
                                ## result -> 0:Uninstall complete, 1:Uninstall error by debendency ##
                                if [ $? -ne 0 ]; then
                                        # Dependency error #
                                        return $C_ERR_CODE
                                fi
                        fi
                        return 0
                }

                C_FUNC_deb_uninstall_process()
                {
                        # uninstall #
                        C_FUNC_show_and_exec "sudo dpkg -P $1"
                        ## result -> 0:Uninstall complete, 1:Uninstall error by debendency ##
                        if [ $? -ne 0 ]; then
                                # Dependency error #
                                return $C_ERR_CODE
                        fi

                        return 0
                }

                if [ $C_system = "rpm" ]; then
                        C_uninstall_process="C_FUNC_rpm_uninstall_process"
                        C_sudo_command=""

                        ##  Check permission by root ##
                        if test `id -un` != "root"; then
                                su -c "$0 $C_argment"
                                exit
                        fi
                else
                        C_uninstall_process="C_FUNC_deb_uninstall_process"
                        C_sudo_command="sudo"

                        sudo echo > /dev/null
                                if [ $? -ne 0 ]; then
                                exit
                        fi
                fi

                $C_function02 "$C_device" "$C_system"

                ##  Uninstall Depend-Package ##
                $C_uninstall_process $C_main_module-$C_device
                if [ $? -ne 0 ]; then
                        exit
                fi

                ##  Delete mine (pkgconfig.sh)  ##
                $C_sudo_command rm -rf $(dirname $0)/${0##*/}

                C_pkgconfigsh=${0##*/}
                C_pkgconfig=${C_pkgconfigsh%%\.sh}
                if [ $C_system = "rpm" ]; then
                        C_lcfile_path="/usr/local/share/${C_pkgconfig}"
                else
                        C_lcfile_path="/usr/share/${C_pkgconfig}"
                fi
                $C_sudo_command rm -rf $C_lcfile_path

                ##  Uninstall Common-Package ##
                $C_uninstall_process $C_main_module-$C_common

                printf "$L_INST_COM_02_02"

        ###############################
        ### Version display process ###
        ###############################
        elif [ $C_argment = "--version" ]; then

            #########################
                ### Judge 32bit/64bit ###
            #########################

                C_FUNC_get_bitconf version
                if [ $? -eq $C_ERR_CODE ]; then
                        exit
                fi

                echo ; $C_function03 "${C_version%%-*}"
                printf "\n$L_INST_COM_03_01"

                if [ $C_system = "rpm" ]; then
                        echo $C_main_module-$C_common-$C_version.$C_arch.$C_system
                        echo $C_main_module-$C_device-$C_version.$C_arch.$C_system
                else
                        echo $C_main_module-${C_common}_${C_version}_$C_arch.$C_system
                        echo $C_main_module-${C_device}_${C_version}_$C_arch.$C_system
                fi
                echo

        elif [ $C_argment = "--pkgconfig" ]; then
                echo $C_version
        fi

fi