milis/bin/mps

#!/bin/bash

versiyon="1.2.4 Milis Paket Sistemi"
iletisim="milisarge@gmail.com"

betikad=${0##*/}
betikyol="$0"
shelltip=$(basename `cat $betikyol | head -n1 | cut -d'!' -f2 | cut -d' ' -f1`)

# sistem araçlarının tespiti ve atanması
#if [ ${shelltip} = "busybox" ] || [ ${shelltip} = "ash" ];then
if [ ${BASH_VERSION} ];then
	wget_progress="--show-progress"
else
	alias sed="busybox sed"
	alias wget="busybox wget"
	wget_progress=""
fi
#alias sed="sed"

if [ -f /etc/mps.conf ];then
. /etc/mps.conf
else
	echo "/etc/mps.conf ayar dosyası bulunamadı!"
fi

if [ -z ${paketdepo+:} ]; then
	paketdepo="/depo/paketler/"
fi

if [ -z ${sunucu+:} ]; then
	sunucu="127.0.0.1:8000/"
fi

git_sunucu="https://notabug.org"
git_sunucu_eski="https://github.com"

[ -d /sources/milis.git/.git ] &&  cat /sources/milis.git/.git/config | grep "url =" | grep "${git_sunucu_eski}" &> /dev/null

if [ $? -eq 0 ];then
	echo "eski git sunucusundan göç ediliyor."
	_gockom="mv /sources/milis.git /sources/milis.git.eski"
	if [ $(whoami) == "root" ];then
		$_gockom
	else
		sudo $_gockom
	fi
fi


if [ -z ${hesap_repo+:} ]; then
	hesap_repo="milislinux/milis"
fi

# kaynak kodların indiği dizin
if [ -z ${kaynak_dizin+:} ]; then
	kaynak_dizin="/sources"
fi

# resmi git reposu adresi
if [ -z ${git_repo+:} ]; then
	git_repo="${git_sunucu}/${hesap_repo}"
fi

# resmi git reposuna ek takip edilecek talimatname depoları
if [ -z ${git_ekrepo+:} ]; then
	git_ekrepo=""
fi

# ek git repolarının kayıt edildiği konum
if [ -z ${git_yereldepo+:} ]; then
	git_ekyereldepo="${kaynak_dizin}"
fi

# resmi git reposunun kayıt edildiği konum
if [ -z ${git_yereldepo+:} ]; then
	git_yereldepo="/sources/milis.git"
fi

if [ -z ${anatalimatname+:} ]; then
	anatalimatname="${git_yereldepo}/talimatname"
fi

if [ -z ${ektalimatname_repo+:} ]; then
	ektalimatname_repo="${git_sunucu}/milislinux/ek-talimatlar"
fi

if [ -z ${talimatname+:} ]; then
	talimatname="/root/talimatname"
fi

if [ -z ${kokdizin+:} ]; then
	kokdizin="/"
fi

#temel paket koruma
if [ -z ${tpk+:} ]; then
	tpk="evet"
fi
if [ -z ${lokal+:} ]; then
	lokal="tr"
fi
if [ -z ${docsil+:} ]; then
	docsil="evet"
fi
if [ -z ${yerelsil+:} ]; then
	yerelsil="silme"
fi
if [ -z ${ektalimatname+:} ]; then
	ektalimatname="/root/talimatlar"
	[ ! -d /root/talimatlar ] && mkdir -p /root/talimatlar
fi

if [ -z ${sunucular+:} ]; then
	sunucular="paketler.milislinux.org"
	awk ' {print;} NR == 1 { print "sunucular=\"paketler.milislinux.org/\""; }' /etc/mps.conf > /etc/mps2.conf
	mv /etc/mps2.conf /etc/mps.conf
else
	_satirno=$(grep -nr "sunucular=(" /etc/mps.conf | cut -d':' -f1)
	if [ ! -z ${_satirno} ];then
		echo "mps.conf düzeltildi.kontrol ediniz."
		sed "${_satirno}s/(/"\""/;${_satirno}s/)/"\""/" /etc/mps.conf > /etc/mps.conf.yeni
		mv /etc/mps.conf.yeni /etc/mps.conf
	fi
fi

if [ -z ${renklendirme+:} ]; then
	renkdurum="--renkli"
fi

if [ -z ${silme_esgec+:} ]; then
	silme_esgec=""
fi

if [ -z ${esgec+:} ]; then
	esgec=""
fi

esgec="xorg xorg-app"

kurulum_onay="evet"
# Bir paketin silinme onayı 1 ise silme onaylanır.
onayli_sil=1
# Bir paketin silinirken etkilenen dizin kontrolü
silme_etki_kontrol=1
# Bir paketin silinirken ters gereklerinin gösterilmesi
silme_tersbag=0

VT="/var/lib/pkg/DB"
TARIHCE_DIZIN="/var/lib/pkg/tarihce"
LOGDIZIN="/var/log/mps"
tekrarkur="hayir"
logdosya="/var/log/mps/mps.log"
GRUP_DOSYA="/sources/milis.git/ayarlar/gruplar"

# Türkçe Mesajlar
_paket_adi_gerekli="paket ismi eksik!"
_dizin_bulunamadi="dizin bulunamadı!"
_talimat_sayisi_fazla="talimatnameler altında birden fazla talimat mevcut!"
_talimat_bulunamadi="ilgili talimat bulunamadı!"
_ek_talimatname_bulunamadi="mps.conf git_ekrepo değişkeni tanımlanmalı!"
_talimatsiz_dizin="ilgili dizinde talimat bulunamadı!"
_dosya_yolu_bulunamadi="dosya yolu bulunamadı!"
_shasum_uyumsuzluk="shasum uyumsuzluğu tespit edildi!"
_gerekler_belirleniyor="bağımlılıkları belirleniyor."
_yerel_paket_yok="mevcut dizinde mps.lz paketi yok!"
_paket_kuruldu="paketi kuruldu."
_paket_kurulu="kurulu"
_paket_kurulu_degil="paketi kurulu değil!"
_paket_silindi="paketi silindi."
_paket_silinsinmi="paketi kaldırılsın mı?"
_paket_tanimsiz="paketi tanımsız!"
_paket_bulunamadi="ilgili paket bulunamadı!"
_paketvt_guncelleniyor="paket veritabanı güncelleniyor."
_paket_onbellek_depoda_var="paketi önbellek depoda bulunmakta."
_paket_depoda_yok="paket depoda bulunmuyor ve gereksiz,"
_siliniyor="siliniyor"
_git_guncelleniyor="git sunucudan güncelleme çekiliyor."
_git_guncel="git deposu güncel"
_git_guncellendi="git deposu güncellendi."
_yerel_esitlendi="yerele eşitleme tamam."
_yerel_esitlendi_olumsuz="yerele eşitleme olumsuz."
_yerel_esitleniyor="yerele eşitleniyor."
_devir_kontrol_iptal="devir kontrolü iptal edildi!"
_surum_kontrol_iptal="sürüm kontrolü iptal edildi!"
_zaten="zaten"
_indiriliyor="indiriliyor"

export _paketguncel=0

hata_olustu(){
	local _hata _mesaj
	[ -z $1 ] && exit 1
	_hata=$1
	case $_hata in
	"_paket_adi_gerekli")
		_mesaj="$_paket_adi_gerekli"
		;;
	"_talimatsiz_dizin")
		_mesaj="$_talimatsiz_dizin"	
		;;
	"_talimat_bulunamadi")
		_mesaj="$_talimat_bulunamadi"	
		;;
	"_yerel_paket_yok")
		_mesaj="$_yerel_paket_yok"	
		;;
	*)
		_mesaj="böyle bir hata yok"
		;;
	esac
	echo ${_mesaj}
	exit 1
}

cikti_renk_ayarla(){
	local cikti
	cikti="--renkli"
	if [ "$1" ]; then
		if [ "$1" = "--renksiz" ];then
			cikti="--renksiz"
		fi
	fi

	if [ $cikti = "--renkli" ];then
		_yaz="ryaz 32"
		_yaz_tm="ryaz 34"
		_yaz_uyari="ryaz 31"
		_yaz_bilgi="ryaz 33"
	else
		_yaz="echo"
		_yaz_tm="echo"
		_yaz_uyari="echo"
		_yaz_bilgi="echo"
	fi
}

icerik_ekle(){
	if [ -f "$1" ];then
		# kurulan paketin sha1sum değerinin alınması
		local _hash1=$(sha1sum $1) 
		paketad=`echo "$1" | cut -d'#' -f1`	
		paketad=`basename $paketad`
		$_yaz_tm "$paketad paketi kuruluyor-> $kokdizin" 
		if [ -f /usr/bin/bsdtar ];then
			bsdtar -C /tmp --extract --file=$1 .PRE 1 2> /tmp/$paketad_pre.log
		else
			tar -C /tmp --extract --file=$1 .PRE 1 2> /tmp/$paketad_pre.log
		fi
		# kos-kur kontrolu
		if [ -f /tmp/.PRE ];then
			if [ "$kokdizin" == "/" ];then
				bash  /tmp/.PRE
			else
				cp /tmp/.PRE $kokdizin/tmp/$paketad.PRE
			fi
			rm  /tmp/.PRE
		fi
		mkdir -p kur.$paketad &&
		if [ -f /usr/bin/bsdtar ];then
			bsdtar xf $1 -C kur.$paketad
		else
			tar xf $1 -C kur.$paketad
		fi
		# yerelsil aktif ise istenmeyen paket dil desteklerinin silinmesi
		if [ -d kur.$paketad/usr/share/locale ] && [ "$yerelsil" == "evet" ];then
			for lkl in `ls kur.$paketad/usr/share/locale/`;do
				if [ "$lkl" != "$lokal" ];then rm -r kur.$paketad/usr/share/locale/$lkl; fi
			done
		fi
		# docsil aktif ise paketinin /usr/share/doc dizininin silinmesi
		if [ -d kur.$paketad/usr/share/doc ] && [ "$docsil" == "evet" ];then
			rm -r kur.$paketad/usr/share/doc
		fi
		mkdir -p $kokdizin$VT/"$paketad" && 
		cp -v -afr kur.$paketad/* $kokdizin > kur.$paketad/kurulan 
		cp kur.$paketad/kurulan /tmp/ && cat kur.$paketad/kurulan | cut -d '>' -f2 > ${kokdizin}${VT}/"$paketad"/kurulan &&
		# kurulan paketin shasum değerinin kurulu paket dosya kaydı
		echo ${_hash1} > ${kokdizin}${VT}/"$paketad"/sha1
		#mv  kur.$paketad/.MTREE $VT/"$paketad"/files &&
		mv  kur.$paketad/.META ${kokdizin}${VT}/"$paketad"/META &&
		
		# kur-kos calistirilmasi
		if [ -f kur.$paketad/.POST ];then
			if [ "$kokdizin" == "/" ];then
				bash  kur.$paketad/.POST
			else
				cp kur.$paketad/.POST $kokdizin/tmp/$paketad.POST
			fi
			rm  kur.$paketad/.POST
		fi
		
		rm -r kur.$paketad
		if [ -f $kokdizin/etc/ld.so.conf ];then
			ldconfig -r $kokdizin
		fi
		$_yaz_tm "$paketad $_paket_kuruldu"
		loglama "$paketad $_paket_kuruldu"
	else
		$_yaz_uyari "icerik_ekle:paket konum parametresi boş!!!"
		exit 1
	fi
	
}

# paket silme işlevinin parametrelerinin işlenmesi
_paket_sil_args(){
	if [[ "${args}" =~ "--onayla" ]];then 
		_arg="--onayla";_arg_sil
		onayli_sil=0
	fi	
	
	if [[ "${args}" =~ "--sekyok" ]];then 
		_arg="--sekyok";_arg_sil
		silme_etki_kontrol=0
	fi
	
	if [[ "${args}" =~ "--tersbag" ]];then 
		_arg="--tersbag";_arg_sil
		silme_tersbag=1
	fi
}

paket_sil(){
	local paket kkont sil_onay _silinecekler _sek
	# paket silinmesi için gelen parametrelerin işlenmesi
	_paket_sil_args
	[ -z $1 ] && hata_olustu "_paket_adi_gerekli" || paket=$1
	_silinecekler=/tmp/$paket.sil
	
	if [ "$tpk" = "evet" ] && [ -d "$talimatname/temel/$1" ];then
		$_yaz_uyari "$1 temel sistem paketidir.Silinemez!!!"
		hataloglama "$1 temel sistem paketidir.Silinemez!!!"
	else
		kkont=`kurulu_kontrol "$1"`
		if [ "$kkont" = "kurulu" ];then
			if [ -f "$VT/$paket/kurulan" ];then
                #eski dizin koruma
                #etkilenen_kurtar $1 $cikti
				cat $VT/$paket/kurulan | cut -d '>' -f2 > ${_silinecekler}
				if [ ${silme_tersbag} -eq 1 ];then
					$_yaz_uyari "ters bagimliliklar"
					$_yaz_uyari "------------------"
					ters_bagimli_bilgi "$paket"
					$_yaz_uyari "------------------"
				fi
				# yeni silme etkilenen kurtarma
				# kernel için ayrı paket silme uygulanır.
				if [ ${paket} = "kernel" ];then
					for _kkurtar in  \
						'/boot/grub' \
						'/boot'
					do
						sed -i '\|'\'${_kkurtar}\''|d' ${_silinecekler}
					done
					silme_etki_kontrol=0
				fi
				# diğer paketler için
				[ ${silme_etki_kontrol} -eq 1 ] && silme_etkilenme_tespit $paket
				# silme listesi güncelleme - dizin koruma
				# bir paket silinirken dizin yapısındaki diğer paketlerin dosyaları korunacak.
				if [ -f /tmp/${paket}_kd.liste ];then
					for _kurtar in $(cat /tmp/${paket}_kd.liste);do
						echo "$(grep -v "'${_kurtar}'" ${_silinecekler})" > ${_silinecekler}
					done
					$_yaz_bilgi "etkilenen konumlar korundu."
				#else
					#$_yaz_bilgi "kurtarılacak dosya yok."
				fi
				if [ ${onayli_sil} -eq 0 ];then
					sil_onay="e"
				else
					while true; do
						$_yaz_tm $paket" $_paket_silinsinmi";read -p "e veya h-> " eh
						case $eh in
							[Ee]* ) sil_onay="e"; break;;
							[Hh]* ) break;;
							* ) echo "e veya h";;
						esac
					done
				fi
				if [ "$sil_onay" = "e" ];then
					_konum=$(talimat_bul $paket)									
					[ -f "$_konum/$paket.kos-sil" ] && bash "$_konum/$paket.kos-sil"
					xargs rm -r -f < ${_silinecekler} &&
					rm -r -f "$VT/$paket" &&
					[ -f "$_konum/$paket.sil-kos" ] && bash "$_konum/$paket.sil-kos"
					$_yaz_tm $paket" $_paket_silindi"
					loglama "$paket $_paket_silindi"
					rm -f ${_silinecekler}
				else
					rm -f ${_silinecekler}
				fi
			else
				$_yaz_uyari "kritik mesaj:kurulanlar dosyası yok." 
				hataloglama "kritik mesaj:kurulanlar dosyası yok." 
			fi
		elif [ "$kkont" = "degil" ];then
			$_yaz "$_zaten $paket $_paket_kurulu_degil"
			hataloglama "$_zaten $paket $_paket_kurulu_degil"
		else
			$_yaz "$_paket_tanimsiz"
			hataloglama "$_paket_tanimsiz"
		fi
	fi
}

paket_ara(){
	paket="$1"
	for pkt in `cat /depo/paketler/paket*.vt  | grep $paket |  awk '{print $1}'`; do
		pakdesc=$(find $talimatname $ektalimatname -name "$pkt" | xargs -I %  sed -n '1{p;q}' %/talimat | sed s'/# Tanım: //g');
		$_yaz_tm "$pkt - $pakdesc";
	done
}

paket_liste(){
	mps_paketler_listesi="/tmp/mps_paketler_listesi"
	local cikti _grup
	_grup="yok"
	cikti="--renksiz"
	if [ "$1" ]; then
		if [ "$1" == "--json" ];then
			cikti="--json"
		else
			_grup="$1"
		fi
	fi
	if [ "$2" ]; then
		cikti="$2"
	fi
	#echo "cikti:$cikti"
	#echo "grup:$_grup"
	#exit 1
	if [ $_grup == "yok" ];then
		if [ $cikti == "--json" ];then
			[ -f $mps_paketler_listesi ] && rm -rf $mps_paketler_listesi
			for pkt in $(cat /depo/paketler/paket*.vt  | awk '{print $1}'); do
				printf "$pkt," >> $mps_paketler_listesi
			done
			sed -i s'/.$//' $mps_paketler_listesi
		else
			cat /depo/paketler/paket*.vt  | awk '{print $1}'
		fi
	else
		if [ $cikti == "--json" ];then
			grup_paketler_liste $_grup $cikti
		else
			grup_paketler_liste $_grup
		fi
	fi
}

paket_grup_liste(){
	mps_paket_grup_listesi="/tmp/mps_paket_grup_listesi"
	local cikti _altdizins _ektalname
	cikti="normal"
	if [ "$1" ]; then
		cikti="$1"
	fi
	_altdizins=`find $ektalimatname/ -maxdepth 1 -type d | wc -l`

	if [ $_altdizins -gt 1 ]
	then
		_ektalname=$ektalimatname/*
	else
		_ektalname=""
	fi
	
	_gruplar=`grep -ri "Grup:" $talimatname/* $_ektalname | cut -d':' -f3 | cut -d' ' -f2 | sed 's/^ *//;s/ *$//' | sort -u`
	if [ $cikti == "--json" ];then
		[ -f $mps_paket_grup_listesi ] && rm -rf $mps_paket_grup_listesi
		#printf "[" >> $mps_paket_grup_listesi
		for grp in $(grep -ri "Grup:" $talimatname/* $_ektalname | cut -d':' -f3 | cut -d' ' -f2 | sed 's/^ *//;s/ *$//' | sort -u); do
			printf "$grp," >> $mps_paket_grup_listesi
		done
		sed -i s'/.$//' $mps_paket_grup_listesi
		#printf "]" >> $mps_paket_grup_listesi
	else
		echo $_gruplar
	fi
}

grup_paketler_liste(){
	mps_grup_paketler_listesi="/tmp/mps_grup_paketler_listesi"
	local cikti _grup _paketler
	_grup="$1"
	cikti="normal"
	if [ "$2" ]; then
		cikti="$2"
	fi
	_paketler=`grep -rli "Grup: .*$_grup" $talimatname/* $ektalimatname/* | cut -d':' -f3 | sed 's/^ *//;s/ *$//' | xargs -I {}  dirname {} | xargs -I {}  basename {} | sort -u`
	if [ $cikti == "--json" ];then
		[ -f $mps_grup_paketler_listesi ] && rm -rf $mps_grup_paketler_listesi
		#printf "[" >> $mps_paket_grup_listesi
		for pkt in $(grep -rli "Grup: .*$_grup" $talimatname/* $ektalimatname/* | cut -d':' -f3 | sed 's/^ *//;s/ *$//' | xargs -I {}  dirname {} | xargs -I {}  basename {} | sort -u); do
			printf "$pkt," >> $mps_grup_paketler_listesi
		done
		sed -i s'/.$//' $mps_grup_paketler_listesi
		#printf "]" >> $mps_paket_grup_listesi
	else
		echo $_paketler
	fi
}

kelime_bul(){
	grep --color -H -ri "$1" $talimatname
	grep --color -H -ri "$1" $ektalimatname
}

kurulu_kontrol_test(){
	local _paket kkont _cikti _yaz _yaz_uyari
	_paket=$1
	_cikti="--renkli"
	[ "$2" ] && _cikti="$2"
	cikti_renk_ayarla ${_cikti}
	kkont=`kurulu_kontrol "$1"`
	if [ "$kkont" == "degil" ];then
		$_yaz_uyari "$_paket $_paket_kurulu_degil"
		exit 1
	elif [ "$kkont" == "tanimsiz" ];then
		$_yaz_uyari "$_paket $_paket_tanimsiz"
		exit 1
	fi
}

paket_bilgi(){
	local _paket kkont _cikti
	_paket="$1"
	_cikti="--renkli"
	[ "$2" ] && _cikti="$2"
	cikti_renk_ayarla ${_cikti}
	
	kkont=`kurulu_kontrol "$1"`

	if [ "$kkont" = "kurulu" ];then
		satir=`sed -n '1p' <  $VT/"${_paket}"/META`
		$_yaz "ADI        :" ${satir:1:${#satir}-1} #$_yaz_son
		satir=`sed -n '2p' <  $VT/"${_paket}"/META`
		$_yaz "TANIM      :" ${satir:1:${#satir}-1} #$_yaz_son
		satir=`sed -n '3p' <  $VT/"${_paket}"/META`
		$_yaz "URL        :" ${satir:1:${#satir}-1} #$_yaz_son
		satir=`sed -n '5p' <  $VT/"${_paket}"/META`
		$_yaz "PAKETÇİ    :" ${satir:1:${#satir}-1} #$_yaz_son
		satir=`sed -n '6p' <  $VT/"${_paket}"/META`
		satir=${satir:1:${#satir}-1} 
		printf -v boyut '%d\n' "$satir" 2>/dev/null
		if [ $boyut -lt 1048576 ];then
			boyut=$(($boyut/1024))
			_ek="kb"
		else
			boyut=$(($boyut/1024/1024))
			_ek="mb"
		fi
		$_yaz "KUR BOYUT  :" "$boyut $_ek (tahmini)" #$_yaz_son
		satir=`sed -n '7p' <  $VT/"${_paket}"/META`
		$_yaz "SÜRÜM      :" ${satir:1:${#satir}-1} #$_yaz_son
		satir=`sed -n '8p' <  $VT/"${_paket}"/META`
		$_yaz "DEVİR      :" ${satir:1:${#satir}-1} #$_yaz_son
		satir=`sed -n '9p' <  $VT/"${_paket}"/META`
		$_yaz "PAKETLENME :" `date -d @${satir:1:${#satir}-1}` #$_yaz_son
		satir=`sed -n '10p' <  $VT/"${_paket}"/META`
		$_yaz "MİMARİ     :" ${satir:1:${#satir}-1} #$_yaz_son
		satir=`sed -n '11p' <  $VT/"${_paket}"/META`
		$_yaz "GRUP       :" ${satir:1:${#satir}-1} #$_yaz_son
	elif [ "$kkont" = "degil" ];then
		_konum=$(talimat_bul $1)
		source ${_konum}/talimat
		_ad=$(basename ${_konum})
		_tanim=$(grep -ri "# Tanım:" $_konum/talimat | cut -d ':' -f2-)
		_url=$(grep -ri "# Url:" $_konum/talimat | cut -d ':' -f2-)
		_paketci=$(grep -ri "# Paketçi:" $_konum/talimat | cut -d ':' -f2-)
		_surum=${surum}
		_devir=${devir}
		_grup=$(grep -ri "# Grup:" $_konum/talimat | head -1 | cut -d ':' -f2)
		$_yaz "ADI        :" ${_ad} #$_yaz_son
		$_yaz "TANIM      :" ${_tanim} #$_yaz_son
		$_yaz "URL        :" ${_url} #$_yaz_son
		$_yaz "PAKETÇİ    :" ${_paketci} #$_yaz_son
		$_yaz "SÜRÜM      :" ${_surum} #$_yaz_son
		$_yaz "DEVİR      :" ${_devir} #$_yaz_son
		$_yaz "GRUP       :" ${_grup} #$_yaz_son
		$_yaz_uyari "${_paket} $_paket_kurulu_degil"
	else
		$_yaz_uyari "${_paket} $_paket_tanimsiz"
	fi
}

paket_bilgi_html(){
	_simgedepo="/srv/http/mpsweb/static/simgeler"
	_simgehtmldepo="/static/simgeler"
	_simgedosya=""
	_dosya=$1
	_paket=`echo "${_dosya}" | cut -d'_' -f4-5`
	icerik="<table border=1>"
	# ikon arşive baktırılacak varsa programın kendi ikonu yoksa öntanımlı ikon kullanılacak
	
	if [ -f $_simgedepo/${_paket}.png ];then 
		_simgedosya="$_simgehtmldepo/$_paket.png"
	elif [ -f /usr/share/icons/hicolor/32x32/apps/${_paket}.png ];then 
		cp /usr/share/icons/hicolor/32x32/apps/${_paket}.png $_simgedepo/${_paket}.png
		_simgedosya="$_simgehtmldepo/$_paket.png"
	elif [ `ls $_simgedepo/${_paket}_* 2>/dev/null | head -n1` ];then
		_gecicidosya=`ls $_simgedepo/${_paket}_* 2>/dev/null | head -n1`
		_simgedosya="$_simgehtmldepo/$(ls $_gecicidosya | xargs -I {}  basename {})"
	else
		_simgedosya="$_simgehtmldepo/package.png"
	fi

	icerik+="<tr><td align=center><img src='${_simgedosya}' alt='' weight=40 height=40></img><td></tr>"
	while IFS='' read -r satir || [[ -n "$line" ]]; do
		icerik+="<tr>"
		_sutun_baslik="$(echo $satir | cut -d':' -f1)"
		_sutun_deger="$(echo $satir | cut -d':' -f2-)"
		
		#icerik+="<td>$_sutun_deger</td>"
		if [ "${_sutun_baslik}" != "${_sutun_deger}" ];then 
			icerik+="<td>$_sutun_baslik</td>"
			icerik+="<td>$_sutun_deger</td>"
		fi
		icerik+="</tr>"
	done < "$_dosya"
	
	if [[ "${_sutun_baslik}" == *"${_paket_kurulu_degil}"* ]] || [[ "${_sutun_baslik}" == *"${_paket_tanimsiz}"* ]];then 
		icerik+="<tr bgcolor='red'><td>DURUM</td><td>${_sutun_baslik}</td></tr>"
	else
		icerik+="<tr bgcolor='green'><td>DURUM</td><td>kurulu</td></tr>"
	fi
	icerik+="</table>"
	echo "$icerik" > $_dosya.html
}

# paketlerin toplu tablo gösterimi
paketler_depo_html(){
	icerik="<table border=1>"
	for _paket in $(ls $VT);do
		# ikon arşive baktırılacak varsa programın kendi ikonu yoksa öntanımlı ikon kullanılacak
		_simgedosya="/static/package.png"
		#echo "dosya: $_simgedepo/${_paket}.png"
		[ -f $_simgedepo/${_paket}.png ] && _simgedosya="$_simgehtmldepo/$_paket.png"
		[ $(ls $_simgedepo/${_paket}_* | head -n1) ] && _simgedosya="$_simgehtmldepo/$(ls $_simgedepo/${_paket}_* | head -n1 | xargs -I {}  basename {})"
		icerik+="<tr><td align=center><img src='${_simgedosya}' alt='' weight=40 height=40></img><td><td>$_paket</td></tr>"
	done
	icerik+="</table>"
	echo "$icerik" > /tmp/test.html
}

yeniden_paketle(){
		cd $1
		bsdtar -r -f  ../"$1".mps .META
		bsdtar -r -f  ../"$1".mps *
		cd ..
		lzip -9 "$1".mps
}

talimat_bul(){
	local _apaket _bulunan _sonuc _donus _konum
	[ -z $1 ] && hata_olustu "_paket_adi_gerekli"
	_konum="$talimatname $ektalimatname"
	[ ! -z $2 ] && _konum="$2"
	_donus="-1"
	_apaket="$1"
	_sonuc=$(find $_konum -name ${_apaket} | wc -l)
	if [ ${_sonuc} -eq 0 ];then echo $_donus;return; fi
	_bulunan=$(find $_konum -name ${_apaket} | head -n1)
	#if [ ! -f "${_bulunan}/talimat" ];then hata_olustu "_talimatsiz_dizin";return; fi
	if [ ! -f "${_bulunan}/talimat" ];then echo ${_donus};return; fi
	[ ${_sonuc} -gt 1 ] && echo "$(date +'%F %T') ${_apaket} $_talimat_sayisi_fazla" >> $LOGDIZIN/mps-hata.log
	echo ${_bulunan}
}

paket_analiz(){
	_gcc_uyumsuz_paketler="/tmp/gcc_uyumsuz_paketler"
	_pkvt="paket.vt"
	if [ -z "$1" ];then echo "$_paket_adi_gerekli";exit 1;fi
	local pkt _apaket _konum
	pkt=$1
	if [ -f $pkt ];then
		_apaket=$(basename $pkt |cut -d'#' -f 1)
		_konum=$(talimat_bul $_apaket $anatalimatname)
		_depo_sha=$(cat "$paketdepo$_pkvt"  | grep " $_apaket#" | cut -d' ' -f2)
		_paket_sha=$(sha1sum $pkt | cut -d ' ' -f1)
		if [[ $_konum != "-1" && $_konum != "0" ]];then
			source $_konum/talimat
			if [ -f $pkt ];then
				bsdtar xf $pkt .META 
				if [ -f $PWD/.META ];then
					mv .META  /tmp/$_apaket.META
					satir=$(sed -n '7p' <  /tmp/$_apaket.META)
					psurum=${satir:1:${#satir}-1}
					satir2=$(sed -n '8p' <  /tmp/$_apaket.META)
					pdevir=${satir2:1:${#satir2}-1}
					deposurum=`echo -e "$surum" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
					depodevir=`echo -e "$devir" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
					_surumbilgi="gereken_sürüm:$deposurum ! paket_sürüm:$psurum"
					_devirbilgi="gereken_devir:$depodevir ! paket_devir:$pdevir"
					$_yaz_bilgi "$pkt"
					if [ "$deposurum" != "$psurum" ];then
						$_yaz_uyari "$_surumbilgi"
						echo "$pkt" >> $_gcc_uyumsuz_paketler
					fi
					if [ "$depodevir" != "$pdevir" ];then
						$_yaz_uyari "$_devirbilgi"
						echo "$pkt" >> $_gcc_uyumsuz_paketler
					fi
					if [ "$_paket_sha" != "$_depo_sha" ];then
						$_yaz_uyari "$_shasum_uyumsuzluk"
						echo "$pkt" >> $_gcc_uyumsuz_paketler
					fi
				else
					$_yaz_uyari "$_apaket depoda yok. mps -i $_apaket"
				fi
			else
				$_yaz_uyari "$_apaket depoda yok. mps -i $_apaket"
			fi
		else
			$_yaz_uyari "$1 $_talimat_bulunamadi"
		fi
		rm -f /tmp/$_apaket.META
	else
		$_yaz_uyari "$pkt $_dosya_yolu_bulunamadi"
		exit 0
	fi
}	

paketdepo_analiz(){
	paketvt_guncelle
	_aranandepo=$1
	_uyumsuz_paketler="/tmp/uyumsuz_paketler"
	if [[ -d $_aranandepo && ! -f $_aranandepo ]];then
		rm -f $_uyumsuz_paketler
		_gcc_uyumsuz_paketler="/tmp/gcc_uyumsuz_paketler"
		for pkt in $(ls $_aranandepo*mps.lz);do
			paket_analiz $pkt
			echo "-"
		done
		echo "tarama bitti"
		sort -u $_gcc_uyumsuz_paketler > $_uyumsuz_paketler
		echo "file://$_uyumsuz_paketler"
		exit 0
	else
		$_yaz_uyari "$1 $_dizin_bulunamadi"
		exit 1
	fi
}

derleme_listyap_kontrol(){
	
	if [ -f gerek.liste ];then
		mv gerek.liste gerek.eski.liste
	fi
	if [ -f gerek.konum.liste ];then
		mv gerek.konum.liste gerek.konum.eski.liste
	fi
	touch gerek.liste 
	touch gerek.konum.liste 
}

gerekleri_dosyala(){
	local _altgerek _konum
	_altgerek="$1"
	_konum=$(talimat_bul $_altgerek)
	if [[ $konum != "-1" && $konum != "0" ]];then
		printf "."
		echo "$_altgerek" >> gerek.liste 
		if [ ! -d "$talimatname/temel/$_altgerek" ];then
			echo "$_konum" >> gerek.konum.liste 
		fi
	else
		$_yaz_uyari "$1 $_talimat_bulunamadi"
	fi
}

deps_recursive(){
	local _talimat _deps _temp _pkt _konum _kurkon bagimd
	local _ekle=1
	[ $1 ] && _pkt=$1 || hata_olustu "_talimat_bulunamadi"	
	[ $2 ] && _kurkon=$2 || echo "kurkon tanımsız"
	[ $3 ] && _depsf=$3 || echo "depsf tanımsız"
	printf "-"
	_konum=$(talimat_bul $_pkt)
	_talimat="${_konum}/talimat"
	[ $_kurkon -eq 1 ] && [ `kurulu_kontrol $_pkt` = "kurulu" ] && _ekle=0 
	[ $_ekle -eq 1 ] && echo "@$bag@" >> ${_depsf}
	_deps=$(cat $_talimat | awk '/^#[[:blank:]]*Gerek*/ {print}' | cut -d':' -f2)
	if [ -n "$_deps" ]; then
		bagimd=`echo "$_deps" | sed 's/,/ /g'`
		for bag in $bagimd;do
			#[ $_ekle -eq 1 ] && echo "@$bag@" >> ${_depsf}
			_temp=$(grep -rli "@${bag}@" ${_depsf})
			[ ! -z $_temp ] || deps_recursive $bag $_kurkon ${_depsf}
		done
	fi
	
}

deps(){
	local _depsf="/tmp/deps"
	local _kurkon=0
	local _pkt
	[ $1 ] && _pkt=$1 || hata_olustu "_talimat_bulunamadi"	
	$_yaz "$1 $_gerekler_belirleniyor"
	[ $2 ] && [ $2 == "--kurulu_atla" ] && _kurkon=1
	[ -f ${_depsf} ] && rm -f ${_depsf} && touch ${_depsf}
	deps_recursive $_pkt $_kurkon ${_depsf}
	sed -i 's/@//g' ${_depsf}
	#printf "\n"
	cat ${_depsf}
}

gerekleri_listele(){
	derleme_listyap_kontrol
	local _paket _konum _pkvt
	_konum="$talimatname $ektalimatname"
	[ $1 ] && _paket=$1 || hata_olustu "_talimat_bulunamadi"	
	_pkvt=""
	[ "$2" = "--kurulu_atla" ] && _pkvt="$VT"
	#echo "arama konum: $_konum"
	echo $_paket | awk -v arama_konum="$_konum" -v PKVT="$_pkvt" \
	'''
	function gerekbul(paket,gerekler) { 
		if (ISLENDI[paket]) {
			return
		}
		while((getline satir<paket) >0) {  
			if (satir ~ "# Gerekler:" ){         
				split(satir,gerekb,":");
				split(gerekb[2], gerekler, /[ ,]+/);
				if ( length(gerekler) > 0 ){
					for (i in gerekler){
						if ( i > 1 && length(gerekler[i]) > 0 ){
							ara=gerekler[i]
							konum=talimat_bul(ara);
							
							if (konum != ""){
								if (length(PKVT) > 0 ){ 
									(kk(PKVT "/" ara))? yaz("."):gerekbul(konum)
								}
								else {gerekbul(konum)}
							}
						}
					}
				}
			}
		}
		ISLENDI[paket]=1 ; 
		printf "."
		system("echo $(dirname " paket ") >> gerek.konum.liste")
		system("echo $(basename $(dirname " paket ")) >> gerek.liste")
		close(paket)	
	}
	# kurulu kontrol
	function kk(p) {
	  return !system("test -d \""p"\"");
	}
	
	function yaz(_param){
		printf _param
	}
	
	function talimat_bul(ara){
		cmd= "find " arama_konum " -name " ara " | head -n1 "
		_bulundu=0
		while ( ( cmd | getline talimatyol ) > 0 ) {
			_bulundu=1
			break
		} 
		close(cmd)
		if ( _bulundu == 0 ) {
			print ara " talimatı bulunamadı";
			exit 1
		}
		return talimatyol "/talimat"
	}


	{
		#print FILENAME
		_talimat=$1
		_paket=talimat_bul(_talimat)
		if ( length(_paket) > 0 ){gerekbul(_paket);}
		else {print _talimat " talimatı bulunumadı!"}
		exit 1
	}
	'''
	[ -f gerek.liste ] && cat gerek.liste | tr "\n" " ";echo
}

derleme_listyap(){
	[ "$2" = "--renksiz" ] && cikti_renk_ayarla "$2"
	[ "$3" = "--renksiz" ] && cikti_renk_ayarla "$3"
	$_yaz "$1 $_gerekler_belirleniyor"
	gerekleri_listele $@
}

# -derlist
paket_derle_liste(){
	for dpktyer in `cat $1`;do
		dpkt=`basename $dpktyer`
		echo $dpkt "derleniyor...."
		zorla_derle="yok"
		paket_derle $dpktyer
	done
}

#otomatik derle kontrollu kur
# -derle
paket_derle_kur(){
	tekrarkur="hayir"
	derleme_listyap_kontrol
	derleme_listyap "$1"  && paket_derle_liste gerek.konum.liste
}

# odkp
oto_derle_kur_paketle(){
	paketvt_guncelle
	# mps -kur
	_konum=$(talimat_bul $1)
	paket_inkur_oto $1 &&
	if [ -f  "$_konum/$1.sira" ];then
		$_yaz "sıralı derleme yapılacak."
		paket_derle_liste "$_konum/$1.sira"
	else
		paket_derle_kur $1
	fi 
	rm -rf {gerek.konum.eski,gerek.konum,gerek,kurulanlar,silinenler,gerek.eski}.liste
}

paket_kur_oto(){
	local kpkt pkt pak kliste
	if [ "$1" = "-H" ];then
		ls *.mps.lz > "otokur.list"
		kliste="otokur.list"
	else
		kliste="$1"
	fi
	for kpkt in `cat $kliste`;do
		for pkt in `ls $kpkt* | cut -d'#' -f1`;do
			pak=`ls "$pkt#"*`
			yerelden_kur "$pak" && paket_inkur_oto "$pkt"
		done
	done
	rm -rf otokur.list
}

paket_kur_oto_zorla(){
	local _pak _kliste
	[ ! -z $1 ] && _kliste=$1
	for _kpkt in `cat $_kliste`;do
		for _pkt in `ls $_kpkt* | cut -d'#' -f1`;do
			_pak=`ls "$_pkt#"*`
			paket_sil "$_pkt" "--onayla"
			echo $_pak
			yerelden_kur "$_pak" && paket_inkur_oto "$_pkt"
		done
	done
	rm -rf $_kliste
}

paket_kur_liste(){
	local kpkt pkt pak
	for kpkt in `cat $1`;do
		for pkt in `ls $kpkt* | cut -d'#' -f1`;do
			pak=`ls "$pkt#"*`
			yerelden_kur "$pak"
		done
	done
}

paket_kur_liste_zorla(){
	local kpkt pkt pak
	for kpkt in `cat $1`;do
		for pkt in `ls $kpkt* | cut -d'#' -f1`;do
			pak=`ls "$pkt#"*`
			paket_sil "$kpkt" "--onayla"
			yerelden_kur "$pak"
		done
	done
}

#otomatik kontrollu kur
paket_kur_oto2(){
	derleme_listyap_kontrol
	derleme_listyap "$1" > /dev/null && mps -ok gerek.konum.liste
}

paket_inkur_liste_direk(){
	local kpkt
	for kpkt in `cat $1`;do
		agdan_kur "$kpkt"
	done
}

paket_inkur_liste(){
	local kpkt
	for kpkt in `cat $1`;do
		paket_inkur_oto "$kpkt"
	done
}

# otomatik kontrollu kur
# -kur
paket_inkur_oto(){
	local _cikti
	_cikti="--renkli"
	[ $1 ] && _pkt="$1" || hata_olustu "_paket_adi_gerekli"
	[ $2 ] && _cikti="$2"
	cikti_renk_ayarla $_cikti
	
	local konum anakonum kurdurum _agdan_kur_onay
	derleme_listyap_kontrol
	derleme_listyap ${_pkt} "--kurulu_atla"
	
	for kpkt in `cat gerek.liste`;do	
		# önce talimat-anatalimat karşılaştırması yapılır.
		konum="`find "$talimatname" -name $kpkt`"
		anakonum="`find "$anatalimatname" -name $kpkt`"
		ekkonum="`find "$ektalimatname" -name $kpkt`"
		if [ -f  "$anakonum/talimat" ];then
			# depo ve talimatname sürüm kontrolü
			_gncdurum=""
			[ "$(kurulu_kontrol ${kpkt})" = "kurulu" ] && _gncdurum=$(surum_karsilastir ${kpkt})
			_agdan_kur_onay="x"
			if [ "${_gncdurum}" == "degil" ];then
				_agdan_kur_onay="h"
			elif [ "`dosya_karsilastir $konum/talimat $anakonum/talimat`" = "evet" ];then
				_agdan_kur_onay="e"	
			else
				_agdan_kur_onay="h"
				$_yaz_uyari "$kpkt talimat eşitsizliğinden atlandı." 
			fi
			[ $_agdan_kur_onay == "x" ] && exit 1
			[ $_agdan_kur_onay == "e" ] && agdan_kur "$kpkt" "$_cikti"
		# ek talimatlar için sürüm karşılaştırma henüz yok.farklı depolara bakılarak sağlanacak
		elif [ -f  "$ekkonum/talimat" ];then
			agdan_kur "$kpkt" "$_cikti"
		else
			$_yaz_uyari "$kpkt talimatı bulunamadı!"
		fi
	done
	if [ $(kurulu_kontrol ${_pkt}) = "degil" ];then
		kurdurum="kurulu değil"
	elif [ $(kurulu_kontrol ${_pkt}) = "kurulu" ];then
		kurdurum="kurulu"
		$_yaz "${_pkt} $kurdurum"
	else
		kurdurum="$_paket_tanimsiz"
	fi
	rm -rf *.liste
}

paket_sil_oto(){
	local spkt
	for spkt in `cat $1`;do
		paket_sil "$spkt" "--onayla"
	done
}

paket_sil_oto_onayli(){
	local spkt
	#for spkt in `perl -e 'print reverse <>' $1`;do
	for spkt in $(tac $1);do
		paket_sil "$spkt" "--tersbag"
	done
}

paket_sil_gereklerle(){
	local _onay _tbsnc _paket _dosya _silindi
	[ $1 ] && _paket="$1" || hata_olustu "_paket_adi_gerekli"
	# otomatik onay verme durum kontrolü
	_onay="onay"
	[ $2 ] && _onay="$2";
	
	if [ -d $VT/${_paket} ];then
		_dosya=/tmp/${_paket}.gerekler.liste
		rm -f /tmp/${_paket}.silinecekler
		rm -f /tmp/${_paket}.silinemezler
		
		_sliste=`mktemp`
		_eliste=`mktemp`
		
		bagimli_bilgi_dosyala "${_paket}"
		for _pk in $(cat ${_dosya});do
			_silindi=0
			_tbsnc=$(ters_bagimli_bilgi ${_pk} "kurulu")
			for _tbb in `echo $_tbsnc`;do
				for _benzer in $(grep -ri "${_tbb}" ${_dosya});do
					if [ ${_tbb} = ${_benzer} ];then
						echo ${_pk} >> ${_sliste}
						_silindi=1
					fi
				done
				
				if [ ${_tbb} = ${_paket} ];then
					echo ${_pk} >> ${_sliste}
					_silindi=1
				fi
				if [ $_silindi -eq 0 ];then
					echo ${_pk} >> ${_eliste} 				
				fi
			done
		done
		sort -u  ${_sliste} > /tmp/${_paket}.silinecekler
		sort -u  ${_eliste} > /tmp/${_paket}.silinemezler
		rm -rf ${_eliste} ${_sliste} 
		
		#cat /tmp/${_paket}.silinecekler
		#cat /tmp/${_paket}.silinemezler
		if [ $_onay = "oto" ];then
			paket_sil_oto "/tmp/${_paket}.silinecekler"
		else
			paket_sil_oto_onayli "/tmp/${_paket}.silinecekler"
		fi
	else
		$_yaz "$_zaten ${_paket} $_paket_kurulu_degil"
		exit 1
	fi
}

paket_sil_gereklerle_eski(){
	local _onay _tbs _tbsnc _paket _ustgerek
	[ $1 ] && _paket="$1" || hata_olustu "_paket_adi_gerekli"
	# otomatik onay verme durum kontrolü
	[ $2 ] && _onay="$2";
	_onay="onay"
	
	if [ -d $VT/${_paket} ];then
		bagimli_bilgi_dosyala "${_paket}"
		rm -f /tmp/${_paket}.silinecekler
		touch /tmp/${_paket}.silinecekler
		_tbsnc=$(ters_bagimli_bilgi ${_paket} "kurulu")
		if [ -z "${_tbsnc}" ];then _tbs=0 
		else _tbs=$(echo "$_tbsnc" | wc -l)
		fi
		if [ $_tbs -gt 0 ];then
			$_yaz_uyari "${_paket} silinemez."
			echo "ters gerekleri:";echo "$_tbsnc"
			exit 1
		fi
		for pkaltb in $(cat /tmp/${_paket}.gerekler.liste);do
			if [ -d $VT/$pkaltb ];then
				_tbsnc=""
				_tbsnc=$(ters_bagimli_bilgi $pkaltb "kurulu")
				if [ -z "${_tbsnc}" ];then _tbs=0 
				else _tbs=$(echo "$_tbsnc" | wc -l)
				fi
				echo "$pkaltb >"
				if [ -f ${pkaltb}.tbk.txt ];then
					_ustgerek=$(cat /tmp/${_paket}.silinecekler | grep -f ${pkaltb}.tbk.txt)
					[ ${_ustgerek} ] &&  _tbs=0
				fi
				if [ $_tbs -eq 0 ];then
					$_yaz "$pkaltb silinebilir."
					echo "$pkaltb" >> /tmp/${_paket}.silinecekler
				elif [ "$_tbsnc" = "${_paket}" ];then
					$_yaz "$pkaltb silinebilir."
					echo "$pkaltb" >> /tmp/${_paket}.silinecekler
				else
					$_yaz_uyari "$pkaltb silinemez."
					echo "ters gerekleri: $tbsonuc"
				fi
			else
				$_yaz "$_zaten $pkaltb $_paket_kurulu_degil"
			fi
		done
		
		#cat /tmp/${_paket}.silinecekler
		if [ $_onay = "oto" ];then
			paket_sil_oto "/tmp/${_paket}.silinecekler"
		else
			paket_sil_oto_onayli "/tmp/${_paket}.silinecekler"
		fi
	else
		$_yaz "$_zaten ${_paket} $_paket_kurulu_degil"
		exit 1
	fi
}

paketsiz_talimatlar(){
	for talimatyol in `( ls -d $talimatname/genel/*/*  & ls -d $ektalimatname/*/*  ) | cat`;do
		#echo $talimat
		if [ -d $talimatyol ];then
			talimat=$(basename $talimatyol)
			if [[ ! $(cat $paketdepo/paket*.vt | grep  $talimat#) ]] ;then 
				if [ -d $talimatname/*/*/$talimat ];then
					ack=`grep -e '# Tanım:' $talimatname/genel/*/$talimat/talimat | cut -d':' -f2`
				elif [ -d $ektalimatname/*/$talimat ];then
					ack=`grep -e '# Tanım:' $ektalimatname/*/$talimat/talimat | cut -d':' -f2`
				fi
				printf '%s = %s \n' "$talimat" "$ack"
			fi
		fi
	done
}

paket_guncelle(){
	surum_kontrol $1 $2 $3
	if [ -d "$VT/$1" ];then
		# paket sürümü güncellenirse devir güncelleme pas geçilecek.
		# paketin güncel olması durumu 1 gelirse
		if [ ${_paketguncel} -eq 0 ];then
			devir_kontrol $1 $2 $3
		fi
	fi
	export _paketguncel=0
}

paket_guncelle_oto(){
	derleme_listyap "$1" > /dev/null &&
	local kpkt
	GS_CIKTI="H"
	for kpkt in `cat gerek.konum.liste`;do
		durum=`kurulu_kontrol "$kpkt"`
		if [ "$durum" = "kurulu" ]; then
			paket_guncelle "$kpkt" $GS_CIKTI
		fi
	done
	listeleri_temizle
}

dongu_gosterge(){
	count=0
	total=$1
	pstr="[=======================================================================]"
	while [ $count -lt $total ]; do
	  sleep 0.5 # yapılacak iş veya uyutulur.
	  count=$(( $count + 1 ))
	  pd=$(( $count * 73 / $total ))
	  printf "\r%3d.%1d%% %.${pd}s" $(( $count * 100 / $total )) $(( ($count * 1000 / $total) % 10 )) $pstr
	done
}

t_indeks(){
	# karşılaştırma dosyası -talimatname indeks dönüşü verecek
	[ -z $1 ] && exit 1
	local dosya_t="$1"
	# talimat listesi
	local dosya=`mktemp`
	local dosya_sirasiz=`mktemp`
	
	find ${talimatname}/temel/ -type f -name talimat | xargs -I {} dirname {} >  $dosya
	find ${talimatname}/genel/ -type f -name talimat | xargs -I {} dirname {} >> $dosya
	find ${ektalimatname}/     -type f -name talimat | xargs -I {} dirname {} >> $dosya

	i=1
	sp="/-\|"
	echo -n ' '
	while IFS='' read -r konum || [[ -n "$konum" ]]; do
		printf "\b${sp:i++%${#sp}:1}"
		# Surum-Devir
		isim=$(basename $konum)
		#surum=$(grep -ri ^"surum=" $konum/talimat | cut -d '=' -f2 | awk '{ sub(/[ \t]+$/, ""); print }')
		# sürüm ve devir değişkenlerinin olası boşluklarının kırpılması
		surum=$(grep -ri ^"surum=" $konum/talimat | cut -d '=' -f2 | tr -d [:space:])
		devir=$(grep -ri ^"devir=" $konum/talimat | cut -d '=' -f2 | tr -d [:space:])
		echo "$isim@$surum-$devir" >> $dosya_sirasiz

	done < "$dosya"
	sort $dosya_sirasiz > $dosya_t
	rm -f $dosya $dosya_sirasiz 
}

k_indeks(){
	# karşılaştırma dosyası -sıralı dönüş verecek
	[ -z $1 ] && exit 1
	# sistemde kurulum sıralı dosya dönüş verecek
	[ -z $2 ] && exit 1
	local dosya_k="$1"
	local dosya="$2"
	local dosya_sirasiz=`mktemp`
	
	[ -f $dosya ] && rm -rf $dosya
	ls -rct $VT > $dosya
    
    for _esgec in `echo ${esgec} | tr " " "\n"`;do
		_satirno=$(grep -wxnr "${_esgec}" ${dosya} | cut -d':' -f1)
		[ ! -z ${_satirno} ] && sed  -i "${_satirno}d" ${dosya}
	done
    i=1
	sp="/-\|"
	echo -n ' '
	while IFS='' read -r kpaket || [[ -n "$kpaket" ]]; do

		printf "\b${sp:i++%${#sp}:1}"
		# Surum-Devir
		satir=$(sed -n '1p' <  $VT/${kpaket}/META)
		isim=${satir:1:${#satir}-1} 
		satir=$(sed -n '7p' <  $VT/${kpaket}/META)
		surum=${satir:1:${#satir}-1} 
		satir=$(sed -n '8p' <  $VT/${kpaket}/META)
		devir=${satir:1:${#satir}-1} 
		echo "$isim@$surum-$devir" >> $dosya_sirasiz

	done < "$dosya"
	# alfabetik sıralama
	sort $dosya_sirasiz > $dosya_k
 	rm -f $dosya_sirasiz
}

guncelleme_tespit(){
	# talimatname indeks dosyası
	local dosya_t=`mktemp`
    # kurulum indeks dosyası
    local dosya_k=`mktemp`
    # kuruluma göre sıralı paket listesi
    local dosya_ks=`mktemp`
    # güncellenecek paket listesi sırasız
    local dosya_g=`mktemp`
    # güncellenecek paket liste
    local dosya_son=`mktemp`
    local dosya_sonuc=`mktemp`
    # talimatsız paket listesi
    local dosya_talimatsiz=`mktemp`
    
	t_indeks $dosya_t &
	k_indeks $dosya_k $dosya_ks &
	wait $(jobs -p)
	#set -x
	# talimatname ve kurulu sürüm-devir indeks dosya karşılaştırılması
	grep -vxFf $dosya_t $dosya_k > $dosya_g
	# paketleri çekmek için satır sonu @ ekleme
	sed -i 's/$/@/' $dosya_ks
	for _satir in $(cat $dosya_g);do
		_gpaket=$(echo ${_satir} | cut -d'@' -f1)
		# kurulu olup talimatı olmayan paketlerin tespit edilmesi
		grep -nr "^${_gpaket}@" $dosya_t > /dev/null
		if [ $? -eq 0 ];then
			grep -nr "^${_gpaket}@" $dosya_ks >> $dosya_son
		else
			echo "${_gpaket}" >> $dosya_talimatsiz
		fi
	done
	# güncellenecek paketlerin-kurulum sırasına göre sıralanıp, sadeleştirilmesi
	sort $dosya_son | cut -d':' -f2 | cut -d'@' -f1 > $dosya_sonuc
	# geçici dosyaların silinmesi
	#echo "$dosya_t $dosya_k $dosya_ks $dosya_g $dosya_son"
	rm -f $dosya_t $dosya_k $dosya_ks $dosya_g $dosya_son
	# güncellenecek paket listesi yazdırılması
	printf "\n"
	echo "--------------güncelleme----------------"
	cat $dosya_sonuc
	echo "--------------talimatsız----------------"
	# talimatsız paket listesi yazdırılması
	cat $dosya_talimatsiz																																																				
}		

# deneme aşamasında
guncelleme_tespit_hizli(){
	for _hashd in $(find $VT -name sha1 -type f);do
		_hash=$(cat $_hashd | awk -F" " '{print $1}')
		for pktvt in $(ls ${paketdepo}paket*.vt) ; do
			# hash değerinin paket.vt kontrolü
			printf "$(basename ${_hashd%/*})\t" 
			grep -r ${_hash} ${pktvt} > /dev/null
			if [ ! $? -eq 0 ];then
				echo "-"
			else
				echo "+"
				break
			fi
		done 
	done
	#echo "----"
}

sistem_guncelle_uygula(){
	local _gdosya _onay
	if [ "$1" ]; then
		_gdosya="$1"
	fi
	_onay="yok"
	if [ "$2" ]; then
		_onay="$2"
	fi
	[ $_onay = "evet" ] && GS_CIKTI="E"
	[ ! -f ${_gdosya} ] && exit 1
	for gpkt in `cat ${_gdosya}`;do
		durum=`kurulu_kontrol "$gpkt"`
		if [ "$durum" = "kurulu" ]; then
			paket_guncelle "$gpkt" $GS_CIKTI "E"
		fi
	done
}

sistem_guncelle(){
	local guncelleme_dosya _onay _talimatsiz_dosya
	_onay=0
	if [ "$1" = "evet" ];then
		_onay=1
	fi
	if [ "$1" = "dosya" ];then
		_onay=2
	fi
	if [ "$1" ] && [ -f "$1" ];then
		guncelleme_dosya="$1"
		[ "$2" = "evet" ] && _onay=1
	else
		count=0
		local kpaket _pkliste _konum
		guncelleme_dosya="/tmp/mps.guncellenecekler"
		_talimatsiz_dosya="/tmp/talimatsizpkt.liste"
		rm -f $guncelleme_dosya
		touch $guncelleme_dosya
		rm -f $_talimatsiz_dosya
		touch $_talimatsiz_dosya
		total=`ls $VT | wc -l`
		pstr="[=======================================================================]"
		git_guncelle
		paketvt_guncelle
		GS_CIKTI="H"
		_pkliste=$(mktemp)
		ls -rct $VT > ${_pkliste}
		for _esgec in `echo ${esgec} | tr " " "\n"`;do
			_satirno=$(grep -wxnr "${_esgec}" ${_pkliste} | cut -d':' -f1)
			[ ! -z ${_satirno} ] && sed  -i "${_satirno}d" ${_pkliste}
		done
		
		while [ $count -lt $total ]; do
			count=$(( $count + 1 ))
			pd=$(( $count * 73 / $total ))
			printf "\r%3d.%1d%% %.${pd}s" $(( $count * 100 / $total )) $(( ($count * 1000 / $total) % 10 )) $pstr
			kpaket=$(sed -n ${count}'p' ${_pkliste})
			_konum=$(talimat_bul $kpaket)
			if [ "$_konum" = "-1" ];then
				#$_yaz_uyari "$kpaket $_talimat_bulunamadi $_surum_kontrol_iptal"
				# talimatnamede yer almadığından paketin güncellenmesi es geçilecek.
				echo $kpaket >> $_talimatsiz_dosya
				kpaket=""
			fi
			if [ ! -z $kpaket ];then
				satir=$(sed -n '7p' <  $VT/$kpaket/META)
				ksurum=${satir:1:${#satir}-1}
				satir2=$(sed -n '8p' <  $VT/$kpaket/META)
				kdevir=${satir2:1:${#satir2}-1}
				#deposurum=$(grep " $kpaket#" /depo/paketler/paket.vt | cut -d' ' -f3 | cut -d'#' -f 2 | cut -d'-' -f1)
				
				source $_konum/talimat
				deposurum=`echo -e "$surum" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
				depodevir=`echo -e "$devir" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
				#echo $kpaket "  :  $ksurum --->  $deposurum" "$kdevir --->  $depodevir"
				#sleep 3
				if [ "$ksurum" != "$deposurum" ];then
					#printf "$kpaket -surum: ";echo "$ksurum --->  $deposurum"
					echo $kpaket >> $guncelleme_dosya
				elif [ "$kdevir" != "$depodevir" ];then
					#printf "$kpaket -devir: ";echo "$kdevir --->  $depodevir"
					echo $kpaket >> $guncelleme_dosya
				fi
			fi
		done
		$_yaz "Sistem Güncelleme Taraması Tamamlandı."
		
	fi
	if [ -s "$_talimatsiz_dosya" ];then
		$_yaz_tm "aşağıdaki paketlerin talimatı olmayıp depoda bulunmamaktadırlar!"
		cat $_talimatsiz_dosya
		$_yaz_uyari "mps sildos $_talimatsiz_dosya - komutuyla ilgili paketleri kaldırabilirsiniz."
	fi
	if [ -s "$guncelleme_dosya" ];then
		$_yaz_tm "aşağıdaki paketler güncellenecektir:"
		cat $guncelleme_dosya
		$_yaz_uyari "Güncellemesini istemediğiniz paketleri $guncelleme_dosya dosyasından sildikten sonra onay veriniz!"
		if [ ${_onay} -eq 0 ];then
			while true; do
				$_yaz_tm "listedeki paketler güncellensin mi?";read -p "e veya h-> " eh
				case $eh in
					[Ee]* ) sistem_guncelle_uygula $guncelleme_dosya; break;;
					[Hh]* ) break;;
					* ) echo "e veya h";;
				esac
			done
		elif [ ${_onay} -eq 1 ];then
			sistem_guncelle_uygula $guncelleme_dosya "evet"
		else
			echo "güncelleme dosyanız: $guncelleme_dosya"
			exit 1
		fi
	else
		$_yaz_uyari "Güncellenecek paket bulunamadı!"
	fi
}

surum_kontrol(){
	local _konum pk_sil _paket
	_paket=$1
	GS_CIKTI="E"
	G_ONAY="H"
	if [ "$2" ]; then
		GS_CIKTI="$2"
	fi
	if [ "$3" ]; then
		G_ONAY="$3"
	fi
	local ksurum surum pkt dusuk yuksek durum
	durum="belirsiz"
	satir=`sed -n '7p' <  $VT/$_paket/META`
	ksurum=${satir:1:${#satir}-1} 
	
	
	_konum=$(talimat_bul $_paket)
	if [ "$_konum" = "-1" ];then
		$_yaz_uyari "$_paket $_talimat_bulunamadi $_surum_kontrol_iptal"
		pk_sil="e"
		
		for _esgec in `echo ${silme_esgec} | tr " " "\n"`;do
			if [ "${_esgec}" = "${_paket}" ];then
				pk_sil="h"
				break
			fi
		done
		
		if [ "$pk_sil" = "e" ];then
			$_yaz "$_paket $_paket_depoda_yok $_siliniyor"
			paket_sil "$_paket" "--onayla"
		else
			$_yaz "$_paket silinmesi es geçildi"
		fi
		
	else
	
		source $_konum/talimat

		dusuk=`echo -e "$ksurum\n$surum" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
		
		if [ "$ksurum" = "$surum" ];then
			durum="guncel"
			[ $GS_CIKTI = "E" ] && $_yaz_bilgi "$_paket sürümü güncel"
			#printf "."
		else
			if [ "$ksurum" = "$dusuk" ];then
				durum="yukselt"
			else
				durum="dusur"
			fi
			gun_onay="h"
			if [ "$durum" != "guncel" ];then
				if [ $G_ONAY = "H" ];then
					while true; do
						printf "\n"
						$_yaz_tm "$_paket sürüm $durum""me işlemi uygulanacak. $ksurum <> $surum ";read -p "e veya h-> " eh
						case $eh in
							[Ee]* ) gun_onay="e"; break;;
							[Hh]* ) break;;
							* ) echo "e veya h";;
						esac
					done
				else
					gun_onay="e"
				fi	
				if [ "$gun_onay" = "e" ];then
					if [ -d "$talimatname/temel/$_paket" ]; then
						kurulum_dogrulama_icerik $_paket
						tpk="hayir" 
						paket_sil "$_paket" "--onayla"
						paket_indir $_paket
						pkt=`cat "$paketdepo""paket.vt" | grep "^$_paket " | cut -d' ' -f3`
						icerik_ekle "${paketdepo}${pkt}"
					else
						paket_sil "$_paket" "--onayla"
						paket_inkur_oto $_paket
					fi
					$_yaz_tm "$_paket sürüm güncellemesi yapıldı"
					export _paketguncel=1
				else
					$_yaz_uyari "$_paket sürüm güncellemesi yapılmadı"
					hataloglama "$_paket sürüm güncellemesi yapılmadı"
				fi
			fi
		fi
	fi
	
}

devir_kontrol(){
	local _konum pk_sil _paket
	_paket="$1"
	GS_CIKTI="E"
	G_ONAY="H"
	if [ "$2" ]; then
		GS_CIKTI="$2"
	fi
	if [ "$3" ]; then
		G_ONAY="$3"
	fi
	local kdevir devir pkt dusuk yuksek durum gun_onay
	durum="belirsiz"
	satir=`sed -n '8p' <  $VT/$_paket/META`
	kdevir=${satir:1:${#satir}-1} 
	
	_konum=$(talimat_bul $_paket)
	if [ "$_konum" = "-1" ];then
		$_yaz_uyari "$_paket $_talimat_bulunamadi $_devir_kontrol_iptal"
		pk_sil="e"
		
		for _esgec in `echo ${silme_esgec} | tr " " "\n"`;do
			if [ "${_esgec}" = "${_paket}" ];then
				pk_sil="h"
				break
			fi
		done
		
		if [ "$pk_sil" = "e" ];then
			$_yaz "$_paket $_paket_depoda_yok $_siliniyor"
			paket_sil "$_paket" "--onayla" 
		else
			$_yaz "$_paket silinmesi es geçildi"
		fi
		
	else
	
		source $_konum/talimat
		dusuk=`echo -e "$kdevir\n$devir" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
		
		if [ "$kdevir" = "$devir" ];then
			durum="guncel"
			[ $GS_CIKTI = "E" ] && $_yaz_bilgi "$_paket deviri güncel"
			#printf "."
		else
			if [ "$kdevir" = "$dusuk" ];then
				durum="yukselt"
			else
				durum="dusur"
			fi
			gun_onay="h"
			if [ "$durum" != "guncel" ];then
				if [ $G_ONAY = "H" ];then
					while true; do
						printf "\n"
						$_yaz_tm "$_paket devir $durum""me işlemi uygulanacak. $kdevir <> $devir ";read -p "e veya h-> " eh
						case $eh in
							[Ee]* ) gun_onay="e"; break;;
							[Hh]* ) break;;
							* ) echo "e veya h";;
						esac
					done
				else
					gun_onay="e"
				fi		
				if [ "$gun_onay" = "e" ];then
					paket_sil "$_paket" "--onayla"
					paket_inkur_oto "$_paket"
					$_yaz_bilgi "$_paket devir güncellemesi yapıldı"
				else
					$_yaz_uyari "$_paket devir güncellemesi yapılmadı"
					hataloglama "$_paket devir güncellemesi yapılmadı"
				fi
			fi
		fi 
	fi
}

surum_karsilastir(){
	local kpaket _konum
	[ "$1" ] && kpaket="$1" || exit 1
	deposurum=$(grep " $kpaket#" /depo/paketler/paket.vt | cut -d' ' -f3 | cut -d'#' -f 2 | cut -d'-' -f1)
	_konum=$(talimat_bul $kpaket)
	if [ "$_konum" = "-1" ];then
		$_yaz_uyari "$kpaket $_talimat_bulunamadi $_surum_kontrol_iptal"
		exit 1
	fi
	
	source $_konum/talimat
	tsurum=`echo -e "$surum" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
	if [ "$tsurum" == "$deposurum" ];then
		echo "esit"
	else
		echo "degil"
	fi
}

surum_devir_kontrol(){
	local _konum pk_sil _paket _durum pk_guncelle
	_paket=$1
	_durum="yaz"
	pk_guncelle="e"
	[ $2 ] && _durum="$2"
	local kdevir devir ksurum surum pkt dusuk yuksek durum
	durum="belirsiz"
	if [ -d "$VT/$_paket" ];then
		satir=`sed -n '7p' <  $VT/$_paket/META`
		ksurum="${satir:1:${#satir}-1}-" 
		satir=`sed -n '8p' <  $VT/$_paket/META`
		kdevir=${satir:1:${#satir}-1}
	else
		ksurum="(none)"
		kdevir=""
	fi
	_konum=$(talimat_bul $_paket)
	if [ "$_konum" = "-1" ];then
		echo "$_paket $_talimat_bulunamadi $_surum_kontrol_iptal"
	else
		for _esgec in `echo ${esgec} | tr " " "\n"`;do
			if [ "${_esgec}" = ${_paket} ];then
				pk_guncelle="h"
				break
			fi
		done
		if [ $pk_guncelle == "e" ];then
			source $_konum/talimat
			if [ "${_durum}" == "yaz" ];then
				echo "$_paket:"
				echo "kurulu sürüm :$ksurum$kdevir"
				echo "depo sürüm   :$surum-$devir"
				echo "--"
			else
				if [ "$ksurum$kdevir" == "$surum-$devir" ];then
					echo "yok"
				else
					echo "var"
				fi
			fi
		else
			echo "$_paket için sürüm-devir kontrolü es geçildi."
		fi
	fi
}

_devir_kontrol_durum(){
	local _konum pk_sil _paket
	_paket="$1"
	local kdevir devir pkt dusuk yuksek durum gun_onay
	_kurulu=$(kurulu_kontrol "$_paket")
	if [ ${_kurulu} != "kurulu" ];then 
		ryaz 31 "$_paket $_paket_kurulu_degil"
		exit 1
	fi
	durum="belirsiz"
	satir=`sed -n '8p' <  $VT/$_paket/META`
	kdevir=${satir:1:${#satir}-1} 
	
	_konum=$(talimat_bul $_paket)
	if [ "$_konum" = "-1" ];then
		echo "$_paket $_talimat_bulunamadi $_devir_kontrol_iptal"
	else
	
		source $_konum/talimat
		echo "kurulu devir :$kdevir"
		echo "depo devir   :$devir"
	fi
}

grup_kontrol() {
	local _talimat _grup
	[ -z $1 ] && exit 1
	_talimat="$1"
	_grup=$(LC_ALL=tr_TR.utf-8 grep -ri "Grup:" ${_talimat} | cut -d':' -f2 | sed 's/^ *//;s/ *$//' | cut -d' ' -f1)
	echo "( $_grup ) içermektedir!"
	if [ -z "${_grup}" ];then
		_grup="bos"
		grupad_kontrol $_grup ${_talimat}
	else
		grupad_kontrol $_grup ${_talimat}
	fi
}

grupad_kontrol() {
	local _grup _var _lineno _agrup _talimat
	_var=0
	[ -z $1 ] && exit 1
	[ -z $2 ] && exit 1
	_grup="$1"
	_talimat="$2"
	if [ -f ${GRUP_DOSYA} ];then
		for grup in `cat ${GRUP_DOSYA}`;do
			[ "x${_grup}x" = "x${grup}x" ] && _var=1
		done
		if [ $_var -eq 0 ];then
			cat -n ${GRUP_DOSYA}
			_lineno=$(wc -l ${GRUP_DOSYA} | cut -d' ' -f1)
			if [ $_grup = "bos" ];then
				echo "Talimat grup bilgisi içermemektedir!"
			else
				echo "Talimat geçersiz grup bilgisi( $_grup ) içermektedir!"
			fi
			echo "Yukarıdaki grup numaralarından birini seçiniz!";read -p "No:" _no
			[ $_no -lt 1 ] && grupad_kontrol $_grup ${_talimat}
			[ $_no -gt $_lineno ] && grupad_kontrol $_grup ${_talimat}
			_agrup=$(cat ${GRUP_DOSYA} | sed -n ${_no}p)
			sed -i '/Grup:/d' ${_talimat}
			sed -i "/# Gerekler/a # Grup: $_agrup" ${_talimat}
		fi
	else
		echo "gruplar dosyası yok: ${GRUP_DOSYA}"
	fi
}


talimat_surum_takip(){
	local konum _takip_uzanti
	_takip_uzanti=".takip"
	konum=$(talimat_bul $1)
	if [[ $konum == "-1" || $konum == "0" ]];then
		$_yaz_uyari "$1 $_talimat_bulunamadi"
		exit 1
	else
		if [ -f "$konum/$1$_takip_uzanti" ];then
			source $konum/$1$_takip_uzanti
			if [ "`type -t surum_takip`" = "function" ];then
				$_yaz "$1 paketinin kaynak kod arşivleri inceleniyor..." 
				surum_takip
			else
				$_yaz_uyari "$1 talimatının sürüm takip işlevi yok!"
			fi
		else
			$_yaz_uyari "$1 talimatının takip betiği yok!"
		fi
	fi
}

kaynak_kod_indir(){
	local konum adres adres2
	_kk_indir="wget --no-check-certificate -q ${wget_progress}"
	konum=$(talimat_bul $1)
	if [[ $konum == "-1" || $konum == "0" ]];then
		$_yaz_uyari "$1 $_talimat_bulunamadi"
		exit 1
	else
		source $konum/talimat
		for adres in $kaynak;do
			
			urlkont='(https?|ftp|file)://[-A-Za-z0-9\+&@#/%?=~_|!:,.;]*[-A-Za-z0-9\+&@#/%=~_|]'
			if [[ $adres =~ $urlkont ]];then 
				if [[ $adres =~ "::"  ]];then
					adres2=$(echo $adres | cut -d':' -f-2)
					$_yaz "$adres2 indiriliyor."
					$_kk_indir $adres2
				else
					$_yaz "$adres indiriliyor."
					$_kk_indir $adres
				fi
			else
				$_yaz "$adres kopyalanıyor."
				[ -f $konum/$adres ] && cp  $konum/$adres .
			fi	
		done
	fi
}

paket_derle(){
	#parametre olarak direk konum gelecek
	#eski derleme kalıntılarını temizle
	rm -rf tmp.*
	kaynakdizin_kontrol	
	local konum derleme_onay eh bagimd derpaket _gncdurum
	derleme_onay="h"
	if [ -d "$1" ];then
		konum="$1"
		derpaket=`basename $1`
	else
		konum=$(talimat_bul $1)
		if [[ $konum == "-1" || $konum == "0" ]];then
			$_yaz_uyari "$1 $_talimat_bulunamadi"
			exit 1
		fi
		derpaket="$1"
	fi
	if [ -d "$konum" ];then
		#grup_kontrol $konum/talimat
		mkdir -p tmp."$derpaket" 
		cp -a $konum/* tmp."$derpaket"/
		cd tmp."$derpaket"
		_kurulu=$(kurulu_kontrol "$derpaket")
		# paket kurulu ise kurulu sürüm-devir depoyla kontrol edilir,gerekirse silinip yenisi derlenir.
		if [ "$_kurulu" = "kurulu" ];then
			_gncdurum=$(surum_devir_kontrol ${derpaket} --durum)
			if [ "${_gncdurum}" == "var" ];then
				echo "Kurulu sürüm depodaki sürümden farklı görünüyor depodaki sürüm ile eşitlemek ister misiniz? "
				surum_devir_kontrol ${derpaket}
				paket_sil ${derpaket}
				# paket silinirse kurulu olma durumunu güncellenir.
				_kurulu=$(kurulu_kontrol "$derpaket")
			fi 
		fi
		
		if [ "$_kurulu" = "kurulu" ] && [ "$zorla_derle" = "yok" ];then
			derleme_onay="h"
		else
			derleme_onay="e"
		fi 
		if [ "$derleme_onay" = "e" ];then
			$_yaz_bilgi "$derpaket" "derleniyor...."
			echo "------------------------"
			mpsd -d 2>&1|tee /tmp/"$derpaket".log
			if ( grep "^=======>" /tmp/"$derpaket".log| tail -1 |grep "ERROR"  > /dev/null);then
				echo "derleme sisteminde hata oluştu -----> " /tmp/"$derpaket".log
				exit 1
			fi
			if [ "$kurulum_onay" = "evet" ];then
				for kpkt in `ls $derpaket* | cut -d'#' -f1`;do
					yerelden_kur "$kpkt#"*
				done	
			fi
			mv *.mps.lz ../
		else
			$_yaz "$derpaket $_zaten $_paket_kurulu,yine de derlemek için:
			mps -zd $derpaket"
		fi 
		cd ..
		rm -r tmp."$derpaket"
	else
		$_yaz_uyari "talimat dosyası bulunamadı."
		hataloglama "talimat dosyası bulunamadı."
	fi

}

##_ bagimlilar() : talimatta yer alan gereklerin listesinin alınması.
bagimlilar(){
	local bagimd konum
	konum=$(talimat_bul $1)
	if [[ $konum != "-1" && $konum != "0" ]];then
		bagimd=`cat $konum/talimat | grep "Gerekler" | cut -d':' -f2`
		bagimd=$(echo "$bagimd" | sed 's/,/ /g')										   
		echo "$bagimd"
	else
		echo "$konum"
	fi
}

ters_bagimli_bilgi(){
	local gtbpaket _secim
	_secim="x"
	gtbpaket=$1
	[ "$2" ] && _secim="$2"
	tbgdosya=$(mktemp)
	grep -rli "\s${gtbpaket}\s.*Gerekler\|Gerekler.*\s${gtbpaket}\s" $talimatname > $tbgdosya ; 
	grep -rli "\s${gtbpaket}\s.*Gerekler\|Gerekler.*\s${gtbpaket}\s" $ektalimatname >> $tbgdosya ; 
	grep -rli "\s${gtbpaket}\s.*Gerekler\|Gerekler.*\s${gtbpaket}$" $ektalimatname >> $tbgdosya ; 
	grep -rli "\s${gtbpaket}\s.*Gerekler\|Gerekler.*\s${gtbpaket}$" $talimatname >> $tbgdosya ; 
	cat $tbgdosya | xargs -I {}  dirname {} | xargs -I {}  basename {} | sort > /tmp/${gtbpaket}.tb.txt
	rm -f $tbgdosya
	[ -f /tmp/${gtbpaket}.tbk.txt ] && rm -f /tmp/${gtbpaket}.tbk.txt
	if [ $_secim = "kurulu" ];then
		for _kurulu_pkt in $(cat /tmp/${gtbpaket}.tb.txt);do
			if [ -d $VT/$_kurulu_pkt ];then 
				echo "$_kurulu_pkt" >> /tmp/${gtbpaket}.tbk.txt
			fi
		done
		[ -f /tmp/${gtbpaket}.tbk.txt ] && cat "/tmp/${gtbpaket}.tbk.txt"
	elif [ $_secim = "bilgi" ];then
		for _kurulu_pkt in $(cat /tmp/${gtbpaket}.tb.txt);do
			if [ -d $VT/$_kurulu_pkt ];then 
				echo "$_kurulu_pkt kurulu" >> /tmp/${gtbpaket}.tbk.txt
			else
				echo "$_kurulu_pkt değil" >> /tmp/${gtbpaket}.tbk.txt
			fi
		done
		[ -f /tmp/${gtbpaket}.tbk.txt ] && cat "/tmp/${gtbpaket}.tbk.txt"
	else
		cat "/tmp/${gtbpaket}.tb.txt"
	fi
	rm -rf $tbgdizin
}

kirik_ters_bagimli_bilgi(){
	$_yaz "Aşağıdaki kurulu ters bağımlılıklarda kırılım araması yapılacaktır."
	ters_bagimli_bilgi $1
	$_yaz "........"
	talimatlar=$(cat /tmp/$1.tb.txt)
	for tal in $talimatlar;do
		#paket kuruluysa kontrolu yapılacak
		if [ -d "$VT/$tal" ];then
			$_yaz_bilgi "$tal paketi araştırılıyor:"
			kirik_kontrol_paket $tal
			$_yaz_bilgi "--------------------------"
		fi
	done
}

bagimli_bilgi(){
	local _konum bagimd _dosya _paket
	[ $1 ] && _paket="$1" || hata_olustu "_paket_adi_gerekli"
	_konum=$(talimat_bul $_paket)
	
	if [ "$_konum" = "-1" ];then
		$_yaz_uyari "$_paket tanimsiz"
		exit 0
	else
		bagimd=`cat $_konum/talimat | grep "Gerekler" | cut -d':' -f2`
		if [ -n "$bagimd" ]; then
			bagimd=`echo "$bagimd" | sed 's/,/ /g'`
			for bag in $bagimd;do
				if [ "$2" = "dogrula" ];then
					kurulum_dogrulama_icerik "$bag"
				else
					echo "$bag" "`kurulu_kontrol $bag`"
				fi
			done
		fi
		if [ "$2" = "dogrula" ];then
			kurulum_dogrulama_icerik "$1"
		else
			echo "$1" "`kurulu_kontrol $1`"
		fi
	fi
}

bagimli_bilgi_dosyala(){
	local _konum bagimd _dosya _paket
	[ $1 ] && _paket="$1" || hata_olustu "_paket_adi_gerekli"
	_konum=$(talimat_bul $_paket)
	
	if [ "$_konum" = "-1" ];then
		$_yaz_uyari "$_paket tanimsiz"
		exit 0
	else
		_dosya="/tmp/${_paket}.gerekler.liste"
		rm -f ${_dosya}
		bagimd=`cat $_konum/talimat | grep "Gerekler" | cut -d':' -f2`
		if [ -n "$bagimd" ]; then
			bagimd=`echo "$bagimd" | sed 's/,/ /g'`
			for bag in $bagimd;do
				echo "$bag" >> "/tmp/$1.gerekler.liste"
				#echo "$bag"
				#for _tb in $(ters_bagimli_bilgi $bag);do
				#	echo '|____' $_tb
				#done
			done
		fi
	fi
}

# güncellemelerin alınması talimatname üzerinden
guncellemeler(){
	#diff --changed-group-format='***%>' --unchanged-group-format='' --new-group-format='+++%>'  \
	#$paketdepo/paket.vt.eski $paketdepo/paket.vt | cut -d' ' -f1 | sort --version-sort
	_mps_guncellenecekler="/tmp/mps.guncellenecekler.liste"
	[ -f $_mps_guncellenecekler ] && rm $_mps_guncellenecekler
	for _paket in $(ls $VT);do
		if [ "$(surum_devir_kontrol ${_paket} x)" = "var" ];then
			echo ${_paket} >> $_mps_guncellenecekler
		fi
	done 
	if [ -f $_mps_guncellenecekler ];then
		echo "guncellenecek liste"
		echo "-------------------"
		cat $_mps_guncellenecekler
	fi
}

# iki dosyanın içerik karşılaştırması yapar.
dosya_karsilastir(){
	if cmp -s "$1" "$2"
	then
	   echo "evet"
	else
	   echo "degil"
	fi
}

# ip bulma
ip_bul(){
	url='[a www.milislinux.org]'
	domain=`echo $url | sed 's-^[^/]*/*\([^/]*\)/\?.*$-\1-'`
	echo "< $domain"
	ipaddr=`ping -c 1 $domain | sed -n 's@^.*(\([0-9]*\.[0-9]*\.[0-9]*\.[0-9]*\).*$@\1@p' | head -1`
	req_url=`echo $url | sed "s-/[^/]\+-/$ipaddr-"`
	echo req_url
}

# renkli mesaj
ryaz() {
	[ -z "$1" ] && return
	: ${color=$1}
	shift
	case $color in
		0*) echo -e "\\033[${color:-38}m$@\\033[39m";;
		*)  echo -e "\\033[1;${color:-38}m$@\\033[0;39m";;
	esac
	unset color
}

log_analiz(){
	local zaman durum
	zaman=$1
	durum=$2
	if [ -f "/var/log/mps/mps.log" ];then
		cat $logdosya | grep "$zaman" | grep "$durum" | cut -d' ' -f3
	else
		$_yaz_uyari "mps.log bulunamadı!"
		hataloglama "mps.log bulunamadı!"
	fi
}

silme_etkilenme_tespit(){
	local _paket _kliste _eliste dizin
	local _satir _edosya _ipaket _ustdizin
	[ -z $1 ] && hata_olustu "_paket_adi_gerekli" || _paket=$1
	_kliste=`mktemp`
	_eliste=`mktemp`
	#[ -d /tmp/${_paket}_kurtarma ] && rm -rf /tmp/${_paket}_kurtarma
	#mkdir -p /tmp/${_paket}_kurtarma
	[ -f /tmp/${_paket}_kd.liste ] && rm -rf /tmp/${_paket}_kd.liste
	[ -f /tmp/${_paket}_ep.liste ] && rm -rf /tmp/${_paket}_ep.liste
	
	for _temp in $(cat /var/lib/pkg/DB/${_paket}/kurulan);do
		dizin=${_temp//[\']/}
		if [ -d $dizin ] ;then	
			grep --exclude=/var/lib/pkg/DB/${_paket}/kurulan -ri "'${dizin}/" /var/lib/pkg/DB/*/kurulan \
		    | while read -r _isatir ; do
				#echo "$_isatir"
				#echo "$dizin - $_paket -"
				echo "${dizin}" >> ${_kliste}
				_esatir=$(echo ${_isatir} | cut -d ':' -f1)
				_edosya=$(echo ${_isatir} | cut -d ':' -f2)
				_ipaket=$(basename $(dirname ${_esatir}))
				_ustdizin=$(dirname ${_edosya//[\']/})
				#mkdir -p /tmp/${_paket}_kurtarma/${_ustdizin}
				if [ ! -d ${_edosya//[\']/} ];then
					[ ! -f ${_edosya//[\']/} ] && echo "${_edosya//[\']/} dosyası eksik!" 
				fi
				# eksik dosyalar onaylı yekur yapılacak.
				# /var/lib/pkg/kurtarma altına kopayalama seçimli olacak.
				#\
				# cp -rf ${_edosya//[\']/}  /tmp/${_paket}_kurtarma/${_ustdizin} 
				echo "${_ipaket}" >> ${_eliste}
			done
		fi
	done
	if [ -s ${_kliste} ];then
		sort -u  ${_kliste} > /tmp/${_paket}_kd.liste
		$_yaz "etkilenen konumlar"
		cat /tmp/${_paket}_kd.liste
	fi
	if [ -s ${_eliste} ];then
		sort -u  ${_eliste} > /tmp/${_paket}_ep.liste
		$_yaz "etkilenen paketler"
		cat /tmp/${_paket}_ep.liste
	fi
	rm -rf ${_eliste} ${_kliste}
}

eski_etkilenen_kurtar(){
	local dizin paket
	paket=$1
	if [ -f $VT/$paket/kurulan ];then
		cat $VT/$paket/kurulan | cut -d '>' -f2 > /tmp/$paket.sil
		for f in $(cat /tmp/$paket.sil) ; do 
			dizin="${f%\'}"
			dizin="${dizin#\'}"
			if [ -d "$dizin" ];then
				for g in `ls "$dizin"` ; do 
					if ! grep -Fxq " '$dizin/$g'" "/tmp/$paket.sil"
					then
						if [ -f /tmp/$paket.kurtar ];then
							rm /tmp/$paket.kurtar
						fi
						echo " '$dizin'" >> "/tmp/$paket.kurtar"
					fi
				done
			fi
		done
		if [ -f /tmp/$paket.kurtar ];then
			mv $VT/$paket/kurulan $VT/$paket/ilk.kurulan
			grep -v -F -x -f "/tmp/$paket.kurtar" "/tmp/$paket.sil" > $VT/$paket/kurulan
			$_yaz "$paket etkilenen dosyaları kurtarıldı."
		else
			$_yaz "$paket etkilenen dosyası yok."
		fi
		rm -f /tmp/$paket.sil
	else
		$_yaz_uyari "kurulan paket yok!"
		hataloglama "kurulan paket yok!"
	fi
}

ters_bagimli_kontrol(){
	ters_bagimli_bilgi $1
	cat /tmp/${1}.tb.txt | sort > tersb.liste
	ls $VT/ | sed  "/$1/d" | sort  > simdiki.liste
	comm -12 tersb.liste simdiki.liste
	rm tersb.liste simdiki.liste
}

kurulu_kontrol(){
	local _konum _apaket
	[ -z $1 ] && hata_olustu "_paket_adi_gerekli"
	_apaket=$1
	cikti_renk_ayarla "--renksiz"
	[ $2 ] && cikti_renk_ayarla "$2"
	if [ -d "$kokdizin$VT/$_apaket" ];then
		$_yaz "kurulu"
		exit 0
	fi
	_konum=$(talimat_bul $_apaket)
	
	if [ "$_konum" = "-1" ];then
		$_yaz_uyari "tanimsiz"
	else
		$_yaz_uyari "degil"
	fi
	exit 1
}

sistem_kur(){
	local spaket
	for spaket in `cat $1`;do 
		./$betikad -ik "$spaket" -kok $2;
	done
}

kaynakdizin_kontrol(){
	if [ ! -d $kaynak_dizin ];then
		mkdir $kaynak_dizin
	fi
}

logdizin_kontrol(){
	if [ ! -d $kokdizin$LOGDIZIN ];then
		mkdir $kokdizin$LOGDIZIN	
	fi
	if [ ! -d $kokdizin$LOGDIZIN/derleme ];then
		mkdir $kokdizin$LOGDIZIN/derleme
	fi
	if [ ! -f $kokdizin$LOGDIZIN/mps.log ];then
		touch $kokdizin$LOGDIZIN/mps.log
	fi
	if [ ! -f $kokdizin$LOGDIZIN/mps-hata.log ];then
		touch $kokdizin$LOGDIZIN/mps-hata.log
	fi
	if [ ! -f $kokdizin$LOGDIZIN/mps-git.log ];then
		touch $kokdizin$LOGDIZIN/mps-git.log
	fi
}

tarihce_dkontrol(){
	if [ ! -d $TARIHCE_DIZIN ];then
		mkdir $TARIHCE_DIZIN
	fi
}

temel_tarihce_kontrol(){
	if [ ! -f $TARIHCE_DIZIN/temel-pkvt.tar.lz ];then
		tarihce_olustur "temel"
	fi
}

tarihce_liste(){
	tarihce_dkontrol
	ls $TARIHCE_DIZIN/

}

tarihce_yap(){
	tarihce_dkontrol
	local t_isim
	if [ "$temel_tarihce" = "evet" ];then
		t_isim="temel"
	else
		t_isim=`date +%m-%d-%y.%H%M%S`
	fi
	tarihce_olustur "$t_isim"
}

tarihce_olustur(){
	bsdtar -P -r -f $TARIHCE_DIZIN/"$1"-pkvt.tar $VT
	lzip -9 $TARIHCE_DIZIN/"$1"-pkvt.tar
}

tarihce_yukle(){
	tarihce_dkontrol
	local islem_onay cikis
	sil_onay="h"
	if [ -f $TARIHCE_DIZIN/"$1-pkvt.tar.lz" ];then
		bsdtar -p -o -C /tmp -xf $TARIHCE_DIZIN/"$1-pkvt.tar.lz" 2>/dev/null
		ls /tmp$VT/ > hedef.pkvt
		ls $VT/ > simdiki.pkvt
		grep -v -F -x -f hedef.pkvt simdiki.pkvt > sil.liste
		grep -v -F -x -f simdiki.pkvt hedef.pkvt > kur.liste
		#rm hedef.pkvt simdiki.pkvt
		rm -r /tmp/var
		cikis=""
		if [ -s sil.liste ];then
			$_yaz "silinecekler"
			$_yaz "------------"
			cat sil.liste
		fi
		
		if [ -s kur.liste ];then
			$_yaz "kurulacaklar"
			$_yaz "------------"
			cat kur.liste
		fi
		if [ ! -s sil.liste ] && [ ! -s kur.liste ];then
			$_yaz "sistem zaten hedef durumda!"
			exit 1
		fi
		while true; do
			$_yaz_tm "otomatik geri dönüşüm başlasın mı?";read -p "e veya h-> " eh
			case $eh in
				[Ee]* ) islem_onay="e"; break;;
				[Hh]* ) break;;
				* ) echo "e veya h";;
			esac
		done
		if [ "$islem_onay" = "e" ];then
			paket_sil_oto sil.liste
			mps kurul kur.liste
			mv sil.liste silinenler.liste
			mv kur.liste kurulanlar.liste
			exit 1
		fi
		mv sil.liste sil_iptal.liste	
		mv kur.liste kur_iptal.liste	
	else
		$_yaz_uyari "ilgili tarihce dosyası bulunamadı!"
		hataloglama "ilgili tarihce dosyası bulunamadı!"
	fi
	[ -f $PWD/hedef.pkvt ] && rm $PWD/hedef.pkvt
	[ -f $PWD/simdiki.pkvt ] && rm $PWD/simdiki.pkvt
}

tarihce_sil(){
	tarihce_dkontrol
	if [ -f $TARIHCE_DIZIN/"$1-pkvt.tar.lz" ];then
		rm -f $TARIHCE_DIZIN/"$1-pkvt.tar.lz"
	else
		$_yaz_uyari "ilgili tarihce dosyası bulunamadı!"
		hataloglama "ilgili tarihce dosyası bulunamadı!"
	fi
}

sunucu_ayarla(){
	wget -q --spider "$1/paket.vt"
	yenisun="$1"
	if [ $? -eq 0 ]; then
		sed -i.bak 's/^\(sunucu=\).*/\1"xverix\/"/' /etc/mps.conf
		sed -i "s|xverix|$1|" /etc/mps.conf
		mps -sun
	else
		$_yaz_uyari "Tanımsız paket sunucusu!"
		hataloglama "Tanımsız paket sunucusu!"
	fi
}

loglama(){
	logdizin_kontrol
	echo "$(date +'%F %T') $1" >> "$kokdizin/$LOGDIZIN/mps.log"
}

hataloglama(){
	logdizin_kontrol
	echo "$(date +'%F %T') $1" >> "$kokdizin/$LOGDIZIN/mps-hata.log"
}

indir_talimat_paketle(){
	local dosya _ip _talkonum _ek_talimat_link
	_wget="wget --quiet --no-check-certificate"
	if [ ! -z "$1" ];then dosya=$1;else $_yaz_uyari "link parametre eksik";exit 1;fi
	if [ ! -z "$2" ];then _ip=$2;else $_yaz_uyari "ip tipi parametresi eksik";exit 1;fi
	if [ ! -z "$3" ];then _talkonum=$3;else $_yaz_uyari "talimatname konum parametre eksik";exit 1;fi
	# ek-talimatname altında ilgili talimat var mı kontrol edilir
	
	_ek_talimat_link="${ektalimatname_repo}/raw/master/${dosya}/talimat"
	wget -q --spider ${_ek_talimat_link}
	[ $? -eq 0 ] && dosya=${_ek_talimat_link}
	urlkont='(https?|ftp|file)://[-A-Za-z0-9\+&@#/%?=~_|!:,.;]*[-A-Za-z0-9\+&@#/%=~_|]'
	if [[ $dosya =~ $urlkont ]];then 
		gdosya=`mktemp`
		if [[ $_ip =~ "-6" ]]; then 
			$_yaz "talimat IPv6: ${dosya} linkinden indirildi."
			$_wget $_ip $dosya -O $gdosya
		else
			$_yaz "talimat IPv4: ${dosya} linkinden indirildi."
			$_wget $_ip $dosya -O $gdosya
		fi
		dosya=$gdosya
	else
		$_yaz_uyari "link geçersiz"
		exit 1
	fi
	
	if [ ! -f $dosya ];then
		$_yaz_uyari "$dosya talimat dosyasi yok!"
		exit 1
	fi
	
	local _isim
	_isim=`grep "^name=" $dosya | head -n1 | cut -d'=' -f 2`
	[ -z "${_isim}" ] && _isim=`grep "^isim=" $dosya | head -n1 | cut -d'=' -f 2`
	if [ ! -n "${_isim}" ]; then
		$_yaz_uyari "paket ismi degiskeni bulunamadı!"
		exit 1
	fi
	if [ ! -d $_talkonum/${_isim:0:1}/${_isim} ];then
		mkdir -p $_talkonum/${_isim:0:1}/${_isim}
		cp -f $dosya $_talkonum/${_isim:0:1}/${_isim}/talimat
		talimat_degisken_cevrim $_talkonum/${_isim:0:1}/${_isim}/talimat
		$_yaz "${_isim} talimatı hazırlandı."
	else
		$_yaz_uyari "${_isim} talimatı zaten talimatnamede var!"
        while true; do
			$_yaz_tm ${_isim}" talimatı yenilensin mi?";read -p "e veya h-> " eh
			case $eh in
				[Ee]* ) rm -rf $_talkonum/${_isim:0:1}/${_isim};indir_talimat_paketle $1 "-4" "$ektalimatname/topluluk";break;;
				[Hh]* ) break;;
				* ) echo "e veya h";;
			esac
		done		
	fi
}

talimat_degisken_cevrim(){
	_dosya=$1
	if [ -f $_dosya ];then
		sed  -i 's/name=/isim=/g' $_dosya
		sed  -i 's/$name/$isim/g' $_dosya
		sed  -i 's/${name}/${isim}/g' $_dosya
		sed  -i 's/version=/surum=/g' $_dosya
		sed  -i 's/$version/$surum/g' $_dosya
		sed  -i 's/${version}/${surum}/g' $_dosya
		sed  -i 's/${version%.*}/${surum%.*}/g' $_dosya
		sed  -i 's/release=/devir=/g' $_dosya
		sed  -i 's/$release/$devir/g' $_dosya
		sed  -i 's/${release}/${devir}/g' $_dosya
		sed  -i 's/source=/kaynak=/g' $_dosya
		sed  -i 's/build()/derle()/g' $_dosya
		sed  -i 's/build ()/derle()/g' $_dosya
		sed  -i 's/Description:/Tanım:/g' $_dosya
		sed  -i 's/Description=/Tanım:/g' $_dosya
		sed  -i 's/Url=/Url:/g' $_dosya
		sed  -i 's/description:/Tanım:/g' $_dosya
		sed  -i 's/Description :/Tanım:/g' $_dosya
		sed  -i 's/Packager:/Paketçi:/g' $_dosya
		sed  -i 's/packager:/Paketçi:/g' $_dosya
		sed  -i 's/Packagers:/Paketçi:/g' $_dosya
		sed  -i 's/Packager :/Paketçi:/g' $_dosya
		sed  -i 's/Depends on:/Gerekler:/g' $_dosya
		sed  -i 's/Depends:/Gerekler:/g' $_dosya
		sed  -i 's/Depends on :/Gerekler:/g' $_dosya
		sed  -i '/Maintainer:/d' $_dosya
		sed  -i '/Optional:/d' $_dosya
	else
		$_yaz_uyari "ilgili talimat dosyası bulunamadı."
	fi
}

talimat_olustur(){
if [ "$1" = '?' ];then
	$_yaz_tm "kullanım : mps -to paket_ismi"
else
	local isim
	isim=$1
	mkdir -p $isim
	tee "$isim/talimat" > /dev/null <<EOF
# Tanım: paket açıklaması
# Url: paketin ilgili web sayfası
# Paketçi: paketçi
# Gerekler: 
# Grup:

isim=$isim
surum=1
devir=1
kaynak=()

derle() {
	cd \$isim-\$surum
	./autogen.sh
	./configure --prefix=/usr
	make
	make DESTDIR=\$PKG install
}

EOF
	$_yaz_tm $isim "talimatı oluşturuldu."
fi
}

git_guncelle() {
	kaynakdizin_kontrol
	gitayar_kontrol
	local _yerel
	
	#git deponun sunucudan güncellenmesi
	$_yaz_bilgi "$_git_guncelleniyor : $git_sunucu"
	if [ $(sunucu_erisim ${git_repo}) = "aktif" ];then
		if [ ! -d ${git_yereldepo} ];then
			git clone ${git_repo} ${git_yereldepo}
			#rsync -av ${git_yereldepo}/rootfs/* /
		else
			cd ${git_yereldepo}
			git pull  >& $LOGDIZIN/mps-git.log
			if grep -q "Already\ up-to-date" $LOGDIZIN/mps-git.log; then
				$_yaz "$_git_guncel"
			else
				#ryaz 32 `cat $LOGDIZIN/mps-git.log`
				$_yaz "$_git_guncellendi"
			fi
			
		fi
	else
		$_yaz_uyari "${git_repo} erişim olumsuz.Uzaktan güncelleme alınamadı."
	fi
	if [ -d ${git_yereldepo} ];then
		# git depodan yerel güncellemelerin yapılması
		#baslangic betiklerinin guncellenmesi
		#rsync -aviz -q --delete ${git_yereldepo}/rootfs/lib/services/* /lib/services/
		[ -d /lib/services/ ] && cp --remove-destination -rf ${git_yereldepo}/rootfs/lib/services/* /lib/services/
		# talimatname ve betiklerin güncellenmesi
		_yerel=$(dirname $talimatname)
		cd ${_yerel}
		rm -rf $talimatname ${_yerel}/bin ${_yerel}/ayarlar
		cp -rf ${git_yereldepo}/talimatname/ ${_yerel}/
		cp -rf ${git_yereldepo}/bin ${_yerel}/
		cp -rf ${git_yereldepo}/ayarlar ${_yerel}/
		
		#ikili dosyaların /usr/bin altına kısayol atılması
		for i in ${_yerel}/bin/*; do
			j=`basename $i`
			if [ ! -L /usr/bin/$j ];then
				ln -sf ${_yerel}/bin/$j /usr/bin/$j
			fi
		done
		#kırık linklerin temizlenmesi
		find -L /usr/bin/* -name . -o -type d -prune -o -type l -exec rm {} +
		find -L ${_yerel}/bin/* -name . -o -type d -prune -o -type l -exec rm {} +
		[ -d /root/bin ] && find -L /root/bin/* -name . -o -type d -prune -o -type l -exec rm {} +
		$_yaz "$_yerel_esitlendi"
	else
		$_yaz "$_yerel_esitlendi_olumsuz"
	fi
	# ek git depolarının güncellenmesi
	[[ ! -z ${git_ekrepo} ]] && git_ek_guncelle
}

git_proje_kur(){
	local proje proj_dizin git_link
	git_link="https://notabug.org/milisarge"
	proje="$1"
	proj_dizin="/opt"
	mkdir -p $proj_dizin
	if [ -d "$proj_dizin/$proje" ];then
		cd $proj_dizin/$proje
		git pull
		
		if [ -f mops ];then
			. mops
			mops_gun
		fi	
	else
		git clone "$git_link/$proje" "$proj_dizin/$proje"
		cd $proj_dizin/$proje
		
		if [ -f mops ];then
			. mops
			mops_kur
			mops_sil
			mops_gun
		fi
	fi
	
}	

op_kur(){
	local mopsyol mops
	mops=$1
	mopsyol="~/mops/$mops"
	# talimatnameye bak
	if [ -d $mopsyol ]; then
		$mopsyol/talimat kur
	# yerelde ara
	elif [ -f $PWD/"$mops" ]; then
		./"$mops" kur
	else
		$_yaz_uyari "$1 mops talimatı bulunamadı!"
	fi
 	
}

op_sil(){
	local mopsyol mops
	mops=$1
	mopsyol="~/mops/$mops"
	# talimatnameye bak
	if [ -d $mopsyol ]; then
		$mopsyol/talimat sil
	# yerelde ara
	elif [ -f $PWD/"$mops" ]; then
		./"$mops" sil
	else
		$_yaz_uyari "$1 mops talimatı bulunamadı!"
	fi
 	
}

servis_kur(){
	cd ${git_yereldepo}/ayarlar/servisler
	if make kur-$1
	then
		 $_yaz "$1 servisi kuruldu"
	else
		 $_yaz_uyari "$1 servisi kurulum olumsuz!!!"
		 hataloglama "$1 servisi kurulum olumsuz!!!"
	fi
	cd -
}

servis_sil(){
	cd ${git_yereldepo}/ayarlar/servisler
	if make sil-$1
	then
		 $_yaz "$1 servisi silindi"
	else
		 $_yaz_uyari "$1 servisi silme olumsuz!!!"
		 hataloglama "$1 servisi silme olumsuz!!!"
	fi
	cd -
}

servisler_kontrol(){
	servisler=`ls ${git_yereldepo}/ayarlar/servisler/mbd/init.d`
	for ser in $(ls /etc/init.d/) ; do 
		if [ ! -f ${git_yereldepo}/ayarlar/servisler/mbd/init.d/$ser ];then
			printf "%12s %s\n" "$ser mbd kaydı bulunamadı!"
		else
			if cmp -s "${git_yereldepo}/ayarlar/servisler/mbd/init.d/$ser" "$ser"
			then
			   printf "%12s %s\n" "$ser" "mbd uyumsuz"
			else
			   #ryaz 32 "$ser mbd +++++"
			   printf "%12s %s\n" "$ser" "mbd +++++"
			fi
		fi	
	done
}

talimat_bilgi(){
	local _konum _apaket
	_apaket=$1
	[ "$2" ] && cikti_renk_ayarla "$2"
	_konum=$(talimat_bul $_apaket)
	if [ "$_konum" = "-1" ];then
		$_yaz_uyari "$_apaket $_paket_bulunamadi"
		exit 1
	else
		grep "derle()" -B 12 $_konum/talimat |sed '$ d'
		$_yaz "file://$_konum/talimat"
		#$_yaz "https://raw.githubusercontent.com/milisarge/malfs-milis/master/$(echo $_konum | cut -d'/' -f3-6)/talimat"
		$_yaz "${git_sunucu}/${hesap_repo}/raw/master/$(echo $_konum | cut -d'/' -f3-6)/talimat"
	fi
}

talimat_yazdir(){
	local _konum _apaket
	_apaket=$1
	_konum=$(talimat_bul $_apaket)
	if [ "$_konum" = "-1" ];then
		$_yaz_uyari "$_apaket $_paket_bulunamadi"
		exit 1
	else
		cat $_konum/talimat
	fi
}

sistem_kontrol(){
	paketvt_kontrol
	sunucu_kontrol
}


sunucu_erisim(){
	local _sunucu
	[ $1 ] && _sunucu="$1"
	wget --no-check-certificate -q --spider "${_sunucu}"
	if [ $? -eq 0 ]; then
		echo "aktif"
	else
		echo "pasif"
	fi
}

sunucu_kontrol(){
	local _sunucular=$(echo ${sunucular} | tr " " "\n") 
	for _sunucu in ${_sunucular}; do
		[ $(sunucu_erisim ${_sunucu}/paket.vt) = "aktif" ] && $_yaz "${_sunucu} paket sunucu aktif" \
		|| $_yaz_uyari "${_sunucu} sunucu erişim dışı" 
	done
}	

gitayar_kontrol(){
	if [ ! -f /root/.gitconfig ];then
		[ `which git_ssl_iptal` ] && git_ssl_iptal
		[ `which git_otokimlik` ] && git_otokimlik
	fi
}

kirik_kontrol_sistem(){
	local onek sonek
	onek="'"
	sonek="'"
	for paket in `ls $VT/`
	do	
		$_yaz_bilgi $paket "kontrol ediliyor."
		kirik_kontrol_paket $paket
		$_yaz_bilgi $paket "kontrol edildi."
	done
}

kirik_kontrol_paket(){
	local onek sonek
	onek="'"
	sonek="'"
	for kdosya in `kurulum_dosya_listele $1`
	do	
		dosya=${kdosya#$onek}
		dosya=${dosya%$sonek}
		#echo "${dosya}"
		if [ -f $dosya ];then
			if [[ $(milis-ldd -d $dosya | grep not\ found) ]] ;then 
				echo $kdosya 
			fi
		fi
	done
}

kurulum_dogrulama(){
	for kuruland in `ls $VT`
	do
		if [ ! -f "$VT/$kuruland/kurulan" ]; then
			$_yaz "$kuruland hasarlı kurulum tesbiti!"
			rm -r $VT/$kuruland
			paket_indir $kuruland
			yerelden_kur "$paketdepo/$kuruland"*.mps.lz
			$_yaz  "$kuruland hasarlı kurulum onarıldı."
		fi
	done
}

paket_icerik_dogrulama(){
	local dosyayol kontpaketadi tempmpslz pidanayol
	kontpaketadi="$1"
	if [ -f "$paketdepo/$kontpaketadi#"*.mps.lz ];then
		tempmpslz=$(mktemp)
		if [ -d $2 ];then
			pidanayol="$2"
			tar tf "$paketdepo/$kontpaketadi#"*.mps.lz > $tempmpslz
			IFS=''
			while read dosyayol;do
				if [ ! -f $pidanayol$dosyayol ] && [ ! -d $pidanayol$dosyayol ] && [ $dosyayol != ".MTREE" ] && [ $dosyayol != ".META" ]; then
					$_yaz_uyari "$pidanayol$dosyayol hasarlı"
					while true; do
						$_yaz_tm $kontpaketadi" paketi yenilensin mi?";read -p "e veya h-> " eh
						case $eh in
							[Ee]* ) tekrarkur="evet";agdan_kur "$kontpaketadi";break;;
							[Hh]* ) break;;
							* ) echo "e veya h";;
						esac
					done
				fi
			done < $tempmpslz
		else
			$_yaz_uyari "$2 kök dizini bulunamadı!"
			exit 1
		fi
	else
		$_yaz_uyari "$1 paketi bulunamadı!"
		exit 1
	fi
}


kurulum_dogrulama_icerik_tum(){
	$_yaz_bilgi  "paket veritabanı yedekleniyor"
	tarihce_yap
	for kurulanpak in `ls $VT`
	do
		if [ -f "$VT/$kurulanpak/kurulan" ]; then
			kurulum_dogrulama_icerik $kurulanpak
			$_yaz  "$kurulanpak kurulum icerik onarıldı."
		fi
	done
}

chr_yordam() {
  [ "$1" -lt 256 ] || return 1
  printf "\\$(printf '%03o' "$1")"
}

ord_yordam() {
  LC_CTYPE=C printf '%d' "'$1"
}

kurulum_dogrulama_icerik(){
	paketadi="$1"
	onar="hayir"	
	#echo $VT
	#tarihce_yap
	$_yaz_uyari  "$paketadi içeriği kontrol ediliyor."
	if [ -f "$VT/$paketadi/kurulan" ]; then
		ilksatir=`head -n 1 $VT/$paketadi/kurulan`
		if [[ `echo ${ilksatir}` =~ ^‘ ]] ; then 
			$_yaz "temel sistem paket kurulan hatası düzeltildi!"
			sed -i 's/‘/'\''\//;s/’/'\''/' $VT/$paketadi/kurulan
		fi
		#for dosyayol in $(cat $VT/$paketadi/kurulan);do
		while read dosyayol; do    
		#for dosyayol in $(<$VT/$paketadi/kurulan);do
			dosyayol=$(echo $dosyayol | sed 's/^.\(.*\).$/\1/')
			netdosyayol="${dosyayol:1:${#dosyayol}-1}"
			if [ ! -f $dosyayol ] && [ ! -d $dosyayol ] ; then
				$_yaz_uyari "$dosyayol hasarlı"
				onar="evet"
			fi
		done < $VT/$paketadi/kurulan

		if [ $onar = "evet" ];then
			$_yaz_tm "$paketadi hasarlı dosya barındırıyor,düzeltilsin mi?";read -p "e veya h-> " eh
			case $eh in
				[Ee]* ) tekrarkur="evet";agdan_kur "$paketadi";;
				[Hh]* ) $_yaz_uyari "$paketadi pas geçildi.";;
				* ) echo "e veya h";;
			esac
		fi
		
		$_yaz "$paketadi kurulum doğrulama tamamlandı." 
	elif [ -d "$VT/$paketadi" ]; then
		cp -rf $VT $VT.yedek
		$_yaz_uyari "$paketadi hasarlı kurulum tesbiti!"
		#onarma
		rm -r $VT/$paketadi
		paket_indir $paketadi
		yerelden_kur "$paketdepo/$paketadi#"*.mps.lz
		$_yaz  "$paketadi hasarlı kurulum onarıldı."
	else
		$_yaz_uyari "$paketadi $_paket_kurulu_degil"
	fi
}

tamir_temel_kurulan(){
	if [ ! -d $VT ] ; then
		$_yaz_uyari "paket kurulum vt bulunamadı!"
		exit 1
	fi
	for paketadi in `ls $VT`
	do
		sed -i 's/‘/'\''\//;s/’/'\''/' $VT/$paketadi/kurulan
	done
}

depo_paketler_liste(){
	ls $paketdepo*.mps.lz
}

depo_paketler_sil(){
	while true; do
		pktsay="0"
		[[ $(ls  $paketdepo*.mps.lz) ]] && pktsay=$(ls $paketdepo/*.mps.lz | wc -l)
		$_yaz_tm "$paketdepo altındaki $pktsay paket silinecek?";read -p "e veya h-> " eh
		case $eh in
			[Ee]* ) rm $paketdepo/*.mps.lz; $_yaz "$paketdepo paketler temizlendi."; break;;
			[Hh]* ) break;;
			* ) echo "e veya h";;
		esac
	done	
}

etkilenenler_sil(){
	while true; do
		$_yaz_tm "etkilenen önbellek silinecek?";read -p "e veya h-> " eh
		case $eh in
			[Ee]* ) rm -rf /var/lib/pkg/etkilenen; $_yaz "etkilenen önbellek temizlendi."; break;;
			[Hh]* ) break;;
			* ) echo "e veya h";;
		esac
	done	
}

kurulum_dosya_listele(){
	cat "$VT/$1/kurulan"
}

# bir dosyanın kurulmuş hangi pakette olduğunu bulur.
kurulan_dosya_bul(){
	grep -rli "$1" "$VT/" | cut -d "/" -f6
}

paketvt_kontrol(){
	mkdir -p /depo/paketler
	if [ ! -f /depo/paketler/paket.vt ];then
		touch /depo/paketler/paket.vt
	fi
}

pvt_olustur(){
	if [ ! -f paket.vt ];then
		touch paket.vt
	fi
	if [ -f "paket.vt" ];then
			mv "paket.vt" "paket.vt.eski"
	fi
	$_yaz "paket.vt oluşturuluyor...."
	for paket in `ls *.mps.lz`
	do
		paketad="`echo $paket|cut -d "#" -f1`"
		shaek=`sha1sum $paket`
		
		echo $paketad $shaek  >> paket.vt  
	done
	$_yaz "paket.vt oluşturuldu."
}

git_ek_guncelle(){
	#echo $git_ekrepo
	local _hesap _repo_ad _repo_hash
	if [[ ! -z ${git_ekrepo} ]];then
		local _repolar=$(echo ${git_ekrepo} | tr " " "\n") 
		# ek git repolarının sırayla güncelleme işlemi
		for _repo in ${_repolar}; do
			#echo $_repo
			_repo_hash="$(printf '%s' "${_repo}" | md5sum | cut -d' ' -f1)"
			_hesap="$(basename $(dirname ${_repo}))"
			_repo_ad="$(basename ${_repo})"
			_repo_islem=${_hesap}-${_repo_ad}-${_repo_hash}
			#git deponun sunucudan güncellenmesi
			$_yaz_bilgi "$_git_guncelleniyor : $_repo"
			if [ $(sunucu_erisim ${_repo}) = "aktif" ];then
				if [ ! -d ${git_ekyereldepo}/${_repo_islem} ];then
					git clone ${_repo} ${git_ekyereldepo}/${_repo_islem}
				else
					cd ${git_ekyereldepo}/${_repo_islem}
					git pull  >& $LOGDIZIN/${_repo_islem}-git.log
					if grep -q "Already\ up-to-date" $LOGDIZIN/${_repo_islem}-git.log; then
						$_yaz "$_git_guncel"
					else
						$_yaz "$_git_guncellendi"
					fi
				fi
				# reponun ek-talimatname altına eşitlenmesi
				[ -d ${ektalimatname}/${_repo_islem} ] && rm -rf ${ektalimatname}/${_repo_islem}
				mkdir ${ektalimatname}/${_repo_islem}
				# repo altındaki talimat içeren dizinlerin kopyalanması
				for talimatd in $(find ${git_ekyereldepo}/${_repo_islem}/ -name talimat | xargs -I {} dirname {});do
					cp -r ${talimatd} ${ektalimatname}/${_repo_islem}/
				done
			else
				$_yaz_uyari "${_repo} erişim olumsuz.Uzaktan güncelleme alınamadı."
			fi		
		done
	else
		$_yaz_uyari "${_ek_talimatname_bulunamadi}"
		echo "git_ekrepo=\"https://gitlab.com/hesap/repo https://notabug.org/hesap/repo\""
		echo "mps.conf içinde yukarıdaki biçimde ek repo(lar) tanımlı olması gerekmektedir."
	fi
}

paketvt_guncelle(){
	local _bakim _sunucular _bakim _sira
	_sunucular=$(echo ${sunucular} | tr " " "\n") 
	_bakim="yok"
	_sira=0
	for pktsunucu in ${_sunucular}; do
	   pkvt=""
	   let _sira=_sira+1
	   if [ ${_sira} = 1 ];then
			pktvt="paket.vt"
	   else
			pktvt="paket${_sira}.vt"
	   fi
	   # sunucu bakım kontrolü
	   [ $(sunucu_erisim "$pktsunucu""paket.vt.yeni") = "aktif" ] &&  _bakim="var"
	   
	   if [ $_bakim = "yok" ];then
		   if [ $(sunucu_erisim "$pktsunucu""paket.vt") = "aktif" ]; then	
				$_yaz $pktsunucu
				$_yaz "$_paketvt_guncelleniyor" "$paketdepo""$pktvt"
				if [ -f "$paketdepo""$pktvt" ];then
					mv "$paketdepo""$pktvt" "$paketdepo""$pktvt.eski"
				fi
				wget --no-check-certificate -q ${wget_progress} -P "$paketdepo" "$pktsunucu""paket.vt" -O "$paketdepo""$pktvt"
				#rm /tmp/paket.vt*
			else
				$_yaz_uyari "$pktsunucu paket veritabanı erişim olumsuz."
				hataloglama "paket veritabanı güncelleme olumsuz."
			fi
		else
			$_yaz_bilgi "$pktsunucu paket veritabanı bakımı yapılıyor." 
			$_yaz_bilgi "5dk içinde tekrar deneyiniz."
		fi
	done
	
}

yuzdelik_filtre ()
{
    local flag=false c count cr=$'\r' nl=$'\n'
    while IFS='' read -d '' -rn 1 c
    do
        if $flag
        then
            printf '%c' "$c"
        else
            if [[ $c != $cr && $c != $nl ]]
            then
                count=0
            else
                ((count++))
                if ((count > 1))
                then
                    flag=true
                fi
            fi
        fi
    done
}

listeleri_temizle(){
	[ -f gerek.liste ] && rm -rf  gerek.liste
	[ -f gerek.konum.liste ] && rm -rf  gerek.konum.liste
}

paket_indir(){
	if [ -f "$paketdepo""paket.vt" ];then
		local _ipaket pkt _indirildi pkvt_hash yerel_hash
		[ $1 ] && _ipaket="$1" || hata_olustu "_paket_adi_gerekli"
		local _sunucular _sira _indir_log
		_indir_log="/tmp/${_ipaket}-indir.log"
		rm -f ${_indir_log}
		_sunucular=$(echo ${sunucular} | tr " " "\n") 
		_sira=0
		_indirildi=0
		for pktsunucu in ${_sunucular}; do
			pkvt=""
			let _sira=_sira+1
			if [ ${_sira} = 1 ];then
				pktvt="paket.vt"
			else
				pktvt="paket${_sira}.vt"
			fi
			if [ -f $paketdepo$pktvt ];then
				#pkt=`cat "$paketdepo$pktvt" | grep "^${_ipaket} " | cut -d' ' -f3`
				# çoklu boşluk ayrıştırma destekli
				pkt=`cat "${paketdepo}${pktvt}" | grep "^${_ipaket} " | awk '{ print $3}'`
				pkvt_hash=`cat "${paketdepo}${pktvt}" | grep "^${_ipaket} " | awk '{print $2}'`
				#ryaz 32 "${_ipaket} paketi $pktsunucu altında aranıyor"
				if [ $pkt ];then
					#ryaz 32 "${_ipaket} paketi $pktsunucu altında bulundu"
					cpaket="${pkt/'#'/'%23'}"
					#paketin sunucuda varlık kontrolu
					wget -q --spider "$pktsunucu$cpaket"
					if [ $? -eq 0 ]; then
						[ ! -f ${paketdepo}${pkt} ] && $_yaz "${_ipaket} $_indiriliyor"
						# -nc ile yerelde ilgili paket varsa pas geçecek ama sonraki adımda sahsum kontrolü yapılacak.
						if [ "${_yaz}" == "echo" ];then
							wget --progress=dot:force -nc --no-check-certificate  -P "$paketdepo" "${pktsunucu}${cpaket}" 2>&1 | tee /tmp/${_ipaket}_indirme.log | sed -u -n 's/[0-9]*%/&/p'
						else
							wget  --no-check-certificate -nc -q ${wget_progress} -P "$paketdepo" "${pktsunucu}${cpaket}" #2>&1 | tee /tmp/${_ipaket}_indirme.log
						fi
						
						if [[ "$?" != 0 ]]; then
							$_yaz_uyari "indirme hatalı"
							hataloglama "indirme hatalı"
						else
							yerel_hash=$(sha1sum "${paketdepo}${pkt}" | awk '{print $1}')
							if [ "${pkvt_hash}" != "${yerel_hash}" ];then
								$_yaz_uyari "$_shasum_uyumsuzluk,paket tekrar indiriliyor."
								hataloglama "sha1sum uyusmaslik tespit edildi,paket tekrar indiriliyor."
								rm -f "${paketdepo}${pkt}" 
								paket_indir "${_ipaket}" "$cikti"
							else
								_indirildi=1
								break
							fi
						fi
					else
						$_yaz_uyari "${_ipaket} paketi bulunamadı $pktsunucu dan silinmiş olmalı!"
					fi
				else
					# paket sunucusunda paket bulunamazsa
					echo "$pktsunucu ${_ipaket} paketi bulunmuyor!" >> ${_indir_log}
				fi
			else
				$_yaz_uyari "$paketdepo altında $pktvt dosyanız yok veya güncelleme yapınız!"
			fi
		done
		# sunucularda paket bulunmama durumu log gösterimi
		if [ ${_indirildi} -eq 0 ];then
			$_yaz_uyari $(cat ${_indir_log})
			# indirileyen fakat önbellekte bulunan paket kontrolü
			if [ -f ${paketdepo}${pkt} ];then
				yerel_hash=$(sha1sum "${paketdepo}${pkt}" | awk '{print $1}')
				# önbellekte mevcut fakat shasum uyum kontrolü
				if [ "${pkvt_hash}" = "${yerel_hash}" ];then
					$_yaz_tm "paketdepo önbelleği kullanılacak."
				else
					$_yaz_uyari "paketdepoda shasum uyumsuz ${_ipaket} paketi bulunmakta!"
				fi
			fi
		fi	
	else
		$_yaz_uyari "$paketdepo altında paket.vt dosyanız yok.Güncelleme yapınız!"
	fi
}


yerelden_kur(){
	local silme _ypaket
	[ $1 ] && _ypaket=$1 || hata_olustu "_yerel_paket_yok"
	if [ $2 ];then
		if [ "$2" == "-kok" ] && [ -d "$3" ]; then
			kokdizin="$3"
			tekrarkur="evet"
		fi
	fi
	pkontrol=`basename ${_ypaket} | grep -w "mps.lz"`
	if [ ! -z "$pkontrol" -a "$pkontrol" != "" ]; then
		paketad=`echo "${_ypaket}" | cut -d'#' -f1`	
		paketad=`basename $paketad`
		kkont=`kurulu_kontrol "$paketad"`		
		if [ "$kkont" = "degil" ];then
			icerik_ekle "${_ypaket}"
		elif [ "$kkont" = "kurulu" ];then
			if [ "$tekrarkur" = "hayir" ];then
				while true; do
					$_yaz_uyari "${_ypaket} paketi zaten kurulu silinip kurulsun mu?"
					read -p "e veya h -> " eh
					case $eh in
						[Ee]* ) silme="e"; break;;
						[Hh]* ) break;;
						* ) echo "e veya h";;
					esac
				done
			fi
			if [ "$silme" = "e" ];then
				$_yaz_bilgi "silinecekelerin kontrolu için"
				paket_sil "$paketad"
				icerik_ekle "${_ypaket}"
			fi
		else
			icerik_ekle "${_ypaket}"
			#while true; do
				#ryaz 31 "${_ypaket} paketi talimatname dışı.Yine de kurulsun mu? (kokdizin=$kokdizin) "
				#read -p "e veya h -> " eh
				#case $eh in
				#	[Ee]* ) icerik_ekle "${_ypaket}"; break;;
				#	[Hh]* ) break;;
				#	* ) echo "e veya h";;
				#esac
			#done
		fi
	else
		$_yaz_uyari "yerelde mps paketi bulunamadı."
	fi
}

agdan_kur(){
	kkont=$(kurulu_kontrol "$1")
	if [ "$kkont" = "degil" ] || [ "$tekrarkur" = "evet" ];then
		paket_indir "$1" "$2"
		if [ $(find $paketdepo -name $1#* | head -1) ];then
			if [ -f $(ls -1t "$paketdepo$1#"* | head -1)  ];then
				if [ "$kurulum_onay" = "evet" ];then
					if [ "$tekrarkur" = "evet" ];then
						paket_sil "$1" "--onayla"
					fi
					#depo/paketler altında birden fazla sürüm kontrolü yapılır,güncel olan seçilir.
					surumler=$(ls "$paketdepo$1#"* | wc -l)
					if [ $surumler = 1 ];then
						icerik_ekle $(ls "$paketdepo$1#"*) $cikti
					elif [ $surumler -gt 1 ];then
						$_yaz_uyari "$1 paketinin birden fazla sürümü var!"
						kurulacak_guncel_paket=$(ls -1t "$paketdepo$1#"* | head -1)
						$_yaz "$kurulacak_guncel_paket sürümü kuruluyor"
						icerik_ekle $kurulacak_guncel_paket $cikti
					fi
				fi
			else
				$_yaz_uyari "$1 indirme hatası"		
			fi
		fi
	elif [ "$kkont" = "kurulu" ];then
		#ryaz 32 "$1 paketi zaten kurulu!"
		printf "."
	else
		$_yaz_uyari "$1 tanımsız paket veya tekrar kurulum iptali var!"
	fi
}

_arg_sil(){
	args=`echo "${args}" | sed -e "s/${_arg}//"`
}

ayarlar() {
	# renkli yazma öntanımlı atamaları
	cikti_renk_ayarla ${renkdurum}
	
	# global değişkenlerin işlenmesi
	args="${@:2}"
	
	### Milis_Paket_Sistemi_Yardim
	### --------------------------
	
	### mps ... --debug|--htbl = mps için hata ayıklama modunu aktifleştirir.
	if [[ "${args}" =~ "--htbl" ]] || [[ "${args}" =~ "--debug" ]];then 
		# args ın global değişkenlerden temizlenmesi
		_arg="--htbl";_arg_sil
		_arg="--debug";_arg_sil
		set -x
	fi
	
	### mps ... --renksiz|--no-color = mps çıktıklarının renksiz yazdırılması.
	if [[ "${args}" =~ "--renksiz" ]] || [[ "${args}" =~ "--no-color" ]];then 
		_arg="--renksiz";_arg_sil
		cikti_renk_ayarla "--renksiz"
	fi
	
	while [ "$1" ]; do
		case $1 in
			### mps -i paketismi = sadece paketi indirir,paket kurulmaz.
			-i|--indir)
				kurulum_onay="olumsuz"
				paket_indir $args
				exit 0 ;;
			### mps -ik paketismi = ilgili paketi indirir ve kurar.
			-ik|--inku)
				if [ "$3" == "-kok" ] && [ -d "$4" ]; then
					kokdizin="$4"
				fi
				agdan_kur "$2" ;;
			### mps -ikz|yekur paketismi = ilgili indirip tekrardan kurar,kurulu olmasına bakılmaz.
			-ikz|yekur)
				tekrarkur="evet"  
				agdan_kur "$2" 
				exit 0 ;;
			### mps -k paketismi..mps.lz = yerel dizindeki paketi kurar.
			-k)
				yerelden_kur $args
				exit 0 ;;
			### mps sil|-s paketismi = ilgili paketi onaylı kaldırır.
			### mps sil|-s paketismi = --onayla -> onaysız kaldırır. (zorla silme)
			-s|sil)
				paket_sil $args
				exit 0 ;;
			### mps gsil paketismi = ilgili paketi güvenli(ters bağımlılıklarına da bakarak) kaldırır.
			gsil)
				paket_sil "$2" "--tersbag"
				exit 0 ;;	
			### mps -S paketismi = ilgili paketi altbağımlılıklarını da sorarak kaldırır.
			### mps -S paketismi = ve oto eklenirse ilgili paketi altbağımlılıklarını da sormadan sırayla kaldırır.
			-S)
				paket_sil_gereklerle $args
				exit 0 ;;
			### mps ara aranan = paket isimleri ve açıklamalarında anahtar kelime arar.
			-pa|ara)
				paket_ara "$2" 
				exit 0 ;;
			### mps bul aranan = talimat dosyaları içinde anahtar kelimeyi arar.
			bul)
				kelime_bul "$2" 
				exit 0 ;;
			### mps -d paketisimi = sadece paketi bağımlıksız derler.Genelde bağımlılığı olmayan paketler için kullanılır.
			-d|--pkde)
				zorla_derle="yok"
				kurulum_onay="olumsuz"
				paket_derle "$2" 
				exit 0 ;;
			### mps -zd paketismi = Pake kurulu olsa bile derleme yapılır.Bağımlıksız derleme için kullanılır.
			-zd|--pkzde)
				zorla_derle="evet"
				kurulum_onay="olumsuz"
				paket_derle "$2" 
				exit 0 ;;
			### mps odkp paketismi = bir paketi bağımlılık zinciri çıkarıp gereklileri önce kurar gerekli olanları derler,paketler ve kurar.
			odkp)
				if [ -d "$talimatname/temel/$2" ] ; then 
					$_yaz_uyari "temel paket için odkp kullanılamaz!"
					exit 1
				fi
				oto_derle_kur_paketle "$2" 
				exit 0 ;;
			### mps god paketismi = mps guncelle && mps odkp paketismi.
			god)
				git_guncelle
				oto_derle_kur_paketle "$2" 
				exit 0 ;;
			### mps -derlist liste = verilen liste dosyasındaki paketleri derler.Alt alta yazılı olmalıdır.
			-derlist)
				paket_derle_liste "$2" 
				exit 0;;	
			### mps derle paketismi = paketismi için bağımlılık zinciri çıkarıp gerekli tüm paketleri derler,paketler ve kurar.
			derle)
				paket_derle_kur "$2"
				exit 0 ;;	
			-ok|--pkok)
				paket_kur_oto "$2" ;;
			-okz)
				paket_kur_oto_zorla "$2" ;;	
			-okl|--pkokl)
				paket_kur_liste "$2" ;;
			-oklz)
				paket_kur_liste_zorla "$2" ;;	
			### mps -kh . = mevcut dizindeki mps.lz uzantılı paketleri onaysız kurar.
			-kh)
				local templist
				templist=`mktemp`
				ls *.mps.lz > $templist
				paket_kur_oto_zorla $templist 
				exit 0 ;;
			-ko|--pkko)
				paket_kur_oto2 "$2" ;;	
			-kuruld)
				paket_inkur_liste_direk "$2" ;;
			### mps kurul liste = verilen liste dosyasındaki paketleri kurar.Alt alta yazılı olmalıdır.
			kurul)
				if [ -f $PWD/mps-liste ]; then
					paket_inkur_liste mps-liste
				else
					paket_inkur_liste "$2"
				fi ;;
			-kur)
				paket_inkur_oto "$2" ;;	
			### mps gkur paketismi = git-paketvt günceller ve yerelde mps.lz varsa yereldekini yoksa sunucudan paketi indirip kurar.
			gkur)
				git_guncelle && paketvt_guncelle && paket_inkur_oto "$2" 
				exit 0 ;;		
			### mps kur paketismi = yerelde mps.lz varsa yereldekini yoksa sunucudan paketi indirip kurar.
			kur)
				if [[ "$2" == *"mps.lz"* ]]; then
					if [ "$3" == "-kok" ] && [ -d "$4" ]; then
						kokdizin="$4"
						tekrarkur="evet"
					fi
					yerelden_kur "$2" "$3"
				else
					paket_inkur_oto "$2" "$3"
				fi 
				exit 0 ;;
			### mps kaynak paketismi = ilgili paketin kaynak kodunu indirir.
			kaynak)
				if [ ! "$2" ]; then
					$_yaz_uyari "paket ismi eksik"
					exit 1
				fi
				kaynak_kod_indir "$2" 
				exit 0 ;;	
			# özel git projesi kurmak için
			gitkur)
				git_proje_kur "$2" ;;
			# otomatik proje sistemi
			# özel git projesi kurmak için
			opk)
				op_kur "$2" ;;
			# özel git projesi silmek için
			ops)
				op_sil "$2" ;;
			### mps serkur paketismi = ilgili paketin servisini kurar
			serkur)
				servis_kur "$2" 
				exit 0 ;;
			### mps sersil paketismi = ilgili paketin servisini siler
			sersil)
				servis_sil "$2" 
				exit 0 ;;
			### mps serkon paketismi = servislerin değişmemezlik kontrolünü yapar.
			serkon)
				servisler_kontrol 
				exit 0 ;;
			### mps kurkos paketismi = ilgili paketin kurulumdan sonraki çalışması gereken betiğini çalıştırır.
			kurkos)
				local pkt
				pkt=$(talimat_bul $2)
				if [ -f  $pkt/$2.kur-kos ];then
					bash $pkt/$2.kur-kos
					exit 0
				else
					$_yaz_uyari "$2 kur-kos yok!"
					hataloglama "$2 kur-kos yok!"
					exit 1
				fi;;
			### mps koskur paketismi = ilgili paketin kurulumdan önceki çalışması gereken betiğini çalıştırır.
			koskur)
				local pkt
				pkt=$(talimat_bul $2)
				if [ -f  $pkt/$2.kos-kur ];then
					bash $pkt/$2.kos-kur
					exit 0
				else
					$_yaz_uyari "$2 kos-kur yok!"
					hataloglama "$2 kos-kur yok!"
					exit 1
				fi ;;
			### mps silkos paketismi = ilgili paketin silindikten sonraki çalışması gereken betiğini çalıştırır.
			silkos)
				local pkt
				pkt=$(talimat_bul $2)
				if [ -f  $pkt/$2.sil-kos ];then
					bash $pkt/$2.sil-kos
					exit 0
				else
					$_yaz_uyari "$2 sil-kos yok!"
					hataloglama "$2 sil-kos yok!"
					exit 1
				fi ;;
			### mps kossil paketismi = ilgili paketin silindikten önceki çalışması gereken betiğini çalıştırır.
			kossil)
				local pkt
				pkt=$(talimat_bul $2)
				if [ -f  $pkt/$2.kos-sil ];then
					bash $pkt/$2.kos-sil
					exit 0
				else
					$_yaz_uyari "$2 kos-sil yok!"
					hataloglama "$2 kos-sil yok!"
					exit 1
				fi ;;
			### mps -kdl paketismi = ilgili paketin sistemdeki kurulmuş olması gereken dosyalarını gösterir.
			-kdl)
				if [ ! "$2" ]; then
					$_yaz_uyari "paket ismi eksik"
					hataloglama "(-kdl) paket ismi eksik"
					exit 1
				fi
				kurulu_kontrol_test   "$2" "$3"
				kurulum_dosya_listele "$2" "$3"
				exit 0 ;;	
			### mps -kkp paketismi = ilgili paketin çalışması için eksik olan dosyaları tespit eder.
			-kkp)
				if [ ! "$2" ]; then
					$_yaz_uyari "paket ismi eksik"
					hataloglama "(-kkp) paket ismi eksik"
					exit 1
				fi
				kirik_kontrol_paket "$2" 
				exit 0 ;;
			### mps kirma paketismi = ilgili paketin sistemde kırdığı paketler tespit edilir.
			kirma)
				if [ ! "$2" ]; then
					$_yaz_uyari "paket ismi eksik"
					hataloglama "(kirma) paket ismi eksik"
					exit 1
				fi
				kirik_ters_bagimli_bilgi "$2" 
				exit 0 ;;
				
			### mps -kks . = sistemde kurulu tüm paketlerin kırık kontrolünü yapar.Eksik dosyaları tespit eder.
			-kks)
				revdep-rebuild
				#kirik_kontrol_sistem
				exit 0 ;;
			### mps -sdk paketismi = bir paketin güncel sürüm numarasını denetler.
			-sdk)
				if [ ! "$2" ]; then
					$_yaz_uyari "paket ismi eksik"
					exit 1
				fi
				surum_devir_kontrol "$2" "$3"
				exit 0 ;;
			### mps -devk paketismi = bir paketin güncel devir numarasını denetler.
			-devk)
				if [ ! "$2" ]; then
					$_yaz_uyari "paket ismi eksik"
					exit 1
				fi
				_devir_kontrol_durum "$2" 
				exit 0 ;;
			-pak|--paketle)
				if [ ! "$2" ]; then
					$_yaz_uyari "paketlenecek dizin ismi eksik"
					hataloglama "paketlenecek dizin ismi eksik"
					exit 1
				fi
				yeniden_paketle "$2" 
				exit 0 ;;
			-psk|--paksiskur)
				if [ ! "$2" ]; then
					$_yaz_uyari "paket liste yok"
					hataloglama "paket liste yok"
					exit 1
				fi
				if [ ! "$3" ]; then
					$_yaz_uyari "hedef dizin yok"
					hataloglama "hedef dizin yok"
					exit 1
				fi
				sistem_kur "$2" "$3" 
				exit 0 ;;
			## mps -po . = mps paketlerinin olduğu dizinde paket.vt oluşturur.
			-po)
				pvt_olustur 
				exit 0 ;;
			## mps sildos dosya = ilgili dosyadaki altalta sıralı paketleri onaysız siler.
			sildos)
				if [ ! "$2" ]; then
					$_yaz_uyari "silme listesi yok"
					hataloglama "silme listesi yok"
					exit 1
				fi
				paket_sil_oto "$2" 
				exit 0 ;;	
			### mps gitsurum . = milis git deposunun güncel git numarasını verir.
			gitsurum)
				# hesap-repo parçalanacak- notabug api araştırılıyor.
				local _udgs=$(curl -s ${git_sunucu}/${hesap_repo} | grep -r 'milislinux\/milis\/commit\/' \
							| head -n1 | awk -F'(>|</a>)' '{print $2}')
				local _ydgs=$(cat ${git_yereldepo}/.git/refs/heads/master)
				printf "uzak_depo:  ${_udgs}\n"
				printf "yerel_depo: ${_ydgs:0:10}\n"
				exit 0 ;;
			### mps liste . = sistemde kurulu olan paket listesini verir.
			-kl|liste)
				ls ${kokdizin}${VT} 
				exit 0 ;;
			### mps dliste . = sistemde kurulu olan ama talimatnamede yer almayan paket listesini verir.
			-dkl|dliste)
				ls ${kokdizin}${VT} | sort > /tmp/mps_krl_pkt.txt
				paket_liste | sort > /tmp/mps_tum_pkt.txt
				comm -23 "/tmp/mps_krl_pkt.txt" "/tmp/mps_tum_pkt.txt"
				rm -rf /tmp/mps_krl_pkt.txt
				rm -rf /tmp/mps_tum_pkt.txt
				exit 0 ;;
			### mps paketler grup_ismi = paket deposundaki paket listesini verir.(grup_ismi verilmezse tüm paketler)
			-ptl|paketler)
				 paket_liste "$2" "$3"
				 exit 0 ;;	
			### mps gruplar . = paket deposundaki paket grup listesini verir.
			-pgl|gruplar)
				 paket_grup_liste "$2" 
				 exit 0 ;;	
			### mps -dly paketismi = ilgili paketin genel ve tüm bağımlılık listesini verir,oluşturur.
			-dly|dliste)
				derleme_listyap $args
				exit 0 ;;	
			### mps -ykp paketismi = ilgili paketin kurulmak istenirse,kurulacak yeni paketleri listeler.
			-ykp)
				#yeni_kurulacak_paketler "$2" 
				derleme_listyap "$2" "--kurulu_atla"
				listeleri_temizle
				exit 0 ;;	
			#sunucu bilgisi alma
			-sun2|sunucu)
				$_yaz $sunucu ;;
			### mps sunucular . = paket sunucularını verir.
			-sun|sunucular)
				#ryaz 32 ${sunucular} ;;
				echo ${sunucular} | tr " " "\n" 
				exit 0 ;;
			sun)
				if [ ! "$2" ]; then
					$_yaz_uyari "sunucu bilgi eksik"
					hataloglama "sunucu bilgi eksik"
					exit 1
				fi
				sunucu_ayarla  "$2" ;;
			### mps -bb paketismi = ilgili paketin gereklerinin durumunu listeler.
			-bb|bagbil)
				bagimli_bilgi "$2" | column -t
				exit 0;;
			-bbdog|bdogrula)
				bagimli_bilgi "$2" "dogrula";;
			-bbd)
				bagimli_bilgi_dosyala $args 
				exit 0 ;;
			### mps -tb talimatismi = ilgili talimata gerek duyan(ters-gerekler) talimatları listeler.
			-tb|tersbag)
				ters_bagimli_bilgi "$2"
				exit 0;;
			-tbb)
				ters_bagimli_bilgi "$2" "bilgi"  | column -t
				exit 0;;
			-tbk)
				ters_bagimli_kontrol "$2" ;;
			### mps pka paketismi = ilgili paketin depo-gitdepo uyumluluğunu kontrol eder.
			pka)
				paket_analiz "$2" 
				exit 0;;
			### mps pda paketdepo = paketlerin olduğu dizindeki paketlerin depo-gitdepo uyumluluğunu kontrol eder.
			pda)
				paketdepo_analiz "$2"
				exit 0 ;;
			### mps tbilgi paketismi = ilgili paketin talimat bilgilerini verir.
			tbilgi)
				talimat_bilgi $args
				exit 0 ;;
			### mps talimat paketismi = ilgili paketin talimatını yazdırır.
			talimat)
				talimat_yazdir "$2"
				exit 0 ;;
			### mps -b paketismi = ilgili paketin kurulum bilgilerini verir.
			-b)
				if [ $2 ];then
					touch "/tmp/mps_paket_bilgi_$2"
					paket_bilgi "$2" "$3"  | tee "/tmp/mps_paket_bilgi_$2"
					if [ $3 ];then
						[ $3 == "--html" ] && paket_bilgi_html "/tmp/mps_paket_bilgi_$2"
					fi
				else
					$_yaz_uyari "paket ismi eksik"
					exit 1
				fi
				exit 0 ;;
			bil)
				if [ $2 ];then
					if [ $3 ];then
						[ $2 == "surum" ] && paket_bilgi "$3" "--renksiz"  | sed -n 6p | cut -d':' -f2 | sed 's/^ *//;s/ *$//'
						[ $2 == "devir" ] && paket_bilgi "$3" "--renksiz"  | sed -n 7p | cut -d':' -f2 | sed 's/^ *//;s/ *$//'
					else
						$_yaz_uyari "paket ismi eksik"
						exit 1
					fi	
				else
					$_yaz_uyari "islev ismi eksik"
					exit 1
				fi
				exit 0 ;;
			phtml)
				paketler_depo_html
				exit 0 ;;
			### mps bilgi paketismi = ilgili paketin talimat ve kurulum bilgilerini verir.
			bilgi)
				paket_bilgi "$2" 
				talimat_bilgi "$2"
				exit 0 ;;
			### mps -to talimat_ismi = ilgili talimat ismine göre talimat şablonu oluşturur.
			-to)
				if [ ! "$2" ]; then
					$_yaz_uyari "talimat ismi eksik"
					hataloglama "talimat ismi eksik"
					exit 1
				fi
				talimat_olustur "$2" 
				exit 0 ;;
			### mps log yyyy-aa-gg olay = mps.log verisi çekmek için (ör: mps log 2017-01-01 silindi)
			log)
				local logyardim
				logyardim="mps log zaman durum (ör: mps log 2017-01-01 silindi)"
				if [ ! "$2" ]; then
					$_yaz_uyari "zaman parametresi eksik"
					hataloglama "zaman parametresi eksik"
					$_yaz $logyardim
					exit 1
				fi
				if [ ! "$3" ]; then
					$_yaz_uyari "durum parametresi eksik"
					hataloglama "durum parametresi eksik"
					$_yaz $logyardim
					exit 1
				fi
				log_analiz "$2" "$3" ;;
			### mps guncelle . = paket veritabanı ve git güncellemesi-talimatname bilgilerini günceller.
			guncelle)
				git_guncelle;
				paketvt_guncelle;
				kurulum_dogrulama;
				#guncelleme_tespit;
				exit 0 ;;
			### mps -G . = paket veritabanı bilgilerini günceller.
			-G|--pvtg)
				paketvt_guncelle
				kurulum_dogrulama
				exit 0 ;;
			### mps -GG . = git güncellemelerini ve talimatname bilgilerini günceller.
			-Ggit|-GG)
				git_guncelle 
				exit 0 ;;
			### mps -GGG . = ek git repo bilgilerini günceller.
			-GGG)
				git_ek_guncelle
				exit 0 ;;
			### mps tespit . = tüm sistemin güncellemesi için güncellenecek paket listesini gösterir.
			tespit)
				guncelleme_tespit
				exit 0 ;;
			tespit2)
				guncelleme_tespit_hizli
				exit 0 ;;
			### mps gun . = güncellenmesi gereken ve depoya yeni eklenen paketleri gösterir.
			gun)
				guncellemeler
				exit 0 ;;
			### mps yukselt . = tüm sistemin güncellemesini gerçekleştirir.
			-GS|yukselt)
				sistem_guncelle $args
				exit 0 ;;
			### mps -g paketismi = ilgili paketi tekil günceller.
			-g|--pkgu)
				git_guncelle  && paketvt_guncelle
				if [ ! "$2" ]; then
					$_yaz_uyari "paket ismi eksik"
					hataloglama "paket ismi eksik"
					exit 1
				fi
				local durum
				durum=`kurulu_kontrol "$2"`
				if [ "$durum" = "kurulu" ]; then
					paket_guncelle "$2"
				elif [ "$durum" = "degil" ]; then
					$_yaz_uyari "$2 $_paket_kurulu_degil"
					hataloglama "$2 $_paket_kurulu_degil"
				else
					$_yaz_uyari "$2 $_paket_tanimsiz"
					hataloglama "$_paket_tanimsiz"
				fi
				exit 0 ;;
			#bagimliliklariyla beraber paket guncelleme-package updating with depencies
			-go|--pkgo)
				if [ ! "$2" ]; then
					$_yaz_uyari "$_paket_adi_gerekli"
					exit 1
				fi
				paket_guncelle_oto "$2";;
			### mps -kk paketismi = ilgili paketin kurulu olma durumunu gösterir.
			-kk)
				kurulu_kontrol $args
				exit 0 ;;
			-kudo)
				kurulum_dogrulama 
				exit 0 ;;
			-kdi|dogrula)
				if [ ! "$2" ]; then
					$_yaz_uyari "$_paket_adi_gerekli"
					exit 1
				fi
				kurulum_dogrulama_icerik "$2" ;;
			-pid|pdogrula)
				kokdzn=""
				if [ ! "$2" ]; then
					$_yaz_uyari "$_paket_adi_gerekli"
					exit 1
				elif [ ! "$3" ]; then
					kokdzn="/"
				else
					kokdzn="$3"
				fi
				paket_icerik_dogrulama "$2" "$kokdzn";;
			-kdit|tumdogrula)
				kurulum_dogrulama_icerik_tum 
				exit 0 ;;
			### mps -set paketismi = ilgili paket silindiğinde etkilenen paketleri ve konumları tespit eder.
			-set)
				[ -z $2 ] && hata_olustu "_paket_adi_gerekli"
				if [ `kurulu_kontrol $1` == "kurulu" ];then
					silme_etkilenme_tespit $args
				else
					$_yaz "$2 $_paket_kurulu_degil"
				fi
				exit 0 ;;
			### mps -suko . = sunucuların erişim kontrolünü yapar.
			-suko)
				sunucu_kontrol 
				exit 0 ;;
			### mps -pot . = talimatı olup ta paketi henüz depoda yer almayan talimatları listeler.
			-pot)
				paketsiz_talimatlar 
				exit 0 ;;
			-dpl|deplist)
				depo_paketler_liste 
				exit 0 ;;
			### mps depsil . = depo/paketler altındaki paket önbelleğini temizler.
			-dps|depsil)
				depo_paketler_sil 
				exit 0 ;;
			### mps etksil . = /var/lib/pkg/etkilenen altındaki kurtarılmış paket önbelleğini temizler.
			-etks|etksil)
				etkilenenler_sil 
				exit 0 ;;
			### mps link url_adres = verilen url adresindeki talimatı ektalimatname/topluluk altına indirir.
			link)
				mkdir -p $ektalimatname/topluluk
				indir_talimat_paketle $2 "-4" "$ektalimatname/topluluk"
				exit 0 ;;
			### mps ti url_adres = verilen url adresindeki talimatı talimatname/genel altına indirir.
			ti)
				indir_talimat_paketle $2 "-4" "$talimatname/genel"
				exit 0 ;;
			-cf|--config-file)
				if [ ! "$2" ]; then
					echo "ayardosyası gerek $1"
					exit 1
				fi
				ayar_dosyasi="$2"
				shift ;;
			### mps -hp aranan = ilgili aranan ifadenin hangi paketlerde olabileceğini listeler.
			-hp)
				if [ ! "$2" ]; then
					$_yaz_uyari "paket ismi eksik"
					exit 1
				fi
				kurulan_dosya_bul "$2"
				exit 0 ;;
			### mps tgs talimat = ilgili talimatın kaynak kodunun yeni sürümü olup olmadığını kontrol eder.
			tgs)
				if [ ! "$2" ]; then
					$_yaz_uyari "talimat ismi eksik"
					exit 1
				fi
				talimat_surum_takip "$2"
				exit 0 ;;
			### mps -tro . = tarihçe noktası oluşturur.
			-tro)
				tarihce_yap 
				exit 0 ;;
			### mps -trot . = temel tarihçe noktası oluşturur.
			-trot)
				temel_tarihce="evet"
				tarihce_yap 
				exit 0 ;;
			### mps -try tarihce_nokta = tarihçe noktasına göre paketleri yükler-siler.
			-try)
				if [ ! "$2" ]; then
					$_yaz_uyari "tarihce dosyasi eksik $1"
					hataloglama "tarihce dosyasi eksik $1"
					exit 1
				fi
				tarihce_yukle "$2"
				exit 1 ;;
			### mps -trl . = tarihçe noktalarını listeler.
			-trl)
				tarihce_liste ;;
			### mps tdc talimat_dosyası = ilgili talimat dosyasının Türkçe değişken çevrimini yapar.
			tdc)
				talimat_degisken_cevrim $2
				exit 0 ;;
			-tamir-tk)
				tamir_temel_kurulan ;;
			### mps dos . = derleme ortamını sıfırlar.temel tarihçeye geri döner.
			dos)
				tarihce_yukle "temel" 
				exit 0 ;;
			-trs)
				if [ ! "$2" ]; then
					$_yaz_uyari "parametre eksik $1"
					hataloglama "parametre eksik $1"
					exit 1
				fi
				tarihce_sil "$2"
				exit 1 ;;
			### mps itest islev_ismi = mps içindeki işlevlerin testi için kullanılmaktadır.
			itest)
				if [ $2 ];then
					_islev="$2"
					if [ "`type -t $_islev`" == "function" ];then
						shift;shift
						$_islev $@
					else
						echo "$_islev işlevi bulunamadı"
					fi
				else
					echo "test edilecek işlev parametresi eksik"
				fi
				exit 0 ;;
			### mps -v . = mps sürüm bilgisini gösterir.
			-v)
				$_yaz_bilgi "$betikad $versiyon  $iletisim $shelltip" 
				#echo  "$betikad $versiyon  $iletisim $shelltip kullanıcı: $SUDO_USER" | bilgi_kutusu
				_exit ;;
			
			-y|-h|yardim)
				yardim_icerik
				exit 0 ;;
			*)
				$_yaz_uyari "Geçersiz Parametre!  --> mps yardim "
				exit 0 ;;
		esac
	done
}
yardim_icerik(){
	cat $betikyol | sed -e 's/^[ \t]*//' | sed -n '/^###/p'  | sed  '/ /s/^###//g' | awk '{split($0,a,"=");  printf "%-6s %-13s %-18s %-40s \n",$1,$2,$3,a[2]}'
}

bilgi_kutusu() {
	: ${title='Bilgi'}
	: ${icon=dialog-information}

	yad --title="$title" --window-icon="$icon" \
		--geometry='600x220+0-24' --fore='#ffffff' --back='#000033' \
		--text-info --fontname=monospace --wrap $opts \
		--button='KAPAT!gtk-quit:1'
}

_exit(){
	echo "exit"
	exit 0
}

ana(){
if [ `id -u` = 0 ] ; then	
	ayarlar "$@"
else
	# sudo yetkisi ile yapılması ve SUDO_USER değişkeninden çalıştıran kullanıcı alınabilir.
	export SUDO_USER=$USER
	sudo mps "$@"
fi
}
ana "$@"


#31 kirmizi
#32 yesil
#33 sari
#34 mavi
#34 mor