Hi
in Anlehnung an rekursiv kompletten Pfad mit Zugriffsdatum ausgeben hier ein Script, um mittels 'find' und 'egrep' rekursiv Ordner und Dateien auszuwählen, diese in einer Vorauswahl zu speichern und dann mit sed zu editieren, umbenennen, durchsuchen.
Ich weiß nicht, ob das ganze sehr nutzbringend ist (geschweige denn fehlerfrei
), wäre aber für Rückmeldungen dankbar !
tom
Hmm, den ersten Fehler gerade gefunden... schade, das keiner was dazu meint...
in Anlehnung an rekursiv kompletten Pfad mit Zugriffsdatum ausgeben hier ein Script, um mittels 'find' und 'egrep' rekursiv Ordner und Dateien auszuwählen, diese in einer Vorauswahl zu speichern und dann mit sed zu editieren, umbenennen, durchsuchen.
Ich weiß nicht, ob das ganze sehr nutzbringend ist (geschweige denn fehlerfrei
), wäre aber für Rückmeldungen dankbar !tom
Code:
#!/bin/sh
## FIND [-repeat]
## zum Auffinden und Editieren von Dateien.
tmp=$HOME'/.FIND.tmp'
rot="\033[00;31m"
blau="\033[00;34m"
def="\033[0m"
##########################
# VERZEICHNISVORAUSWAHL #
##########################
if [ ! "$1" = "-repeat" ] ; then
echo -e $rot'______________________'
echo -e ' VERZEICHNIS: keine Dateivorauswahl=[y]'
echo -n -e $blau' $PWD=[] > '$def
read VERZ
else
VERZ=''
fi
#X###########################
if [ ! "$VERZ" = "y" ] ; then
#X###########################
# Bei Auswahl der Option 'y' springt das Script
# zum Ende der Dateivorauswahl.
if [ -z "$VERZ" ] ; then VERZ=$(pwd) ; fi
VERZ=`echo $VERZ | sed "s|^~|$HOME|g"`
cd $VERZ
echo -n ' pwd: ' ; pwd
# Das Script ist jetzt in das ausgewählte
# Verzeichnis gewechselt.
#X# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#######################
# FIND-OPTION: TYPE #
#######################
echo -e $rot
cat <<!
______________________
TYP:
1) Verzeichnis
2) Datei
3) ausfuehrbare Datei
4) leere Datei
!
echo -n -e $blau' alle=[] > '$def
read wahl
case "$wahl" in
1) opt0='-type d'
;;
2) opt0='-type f'
;;
3) opt0='-type f -a ( -perm +a+x -o -perm +g+x -o -perm +u+x )'
;;
4) opt0='-empty'
;;
*) opt0=' '
;;
esac
# Die erste find-Option (-type) befindet sich in
# der Variablen 'opt0'.
#X# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
########################
# FIND-OPTION: CTIME #
########################
Time () {
echo -e $rot'______________________'
echo -e ' Der Inhalt wurde vor min/max Tagen veraendert:'
echo -e -n $blau' weiter=[] > '$def
read wahl
# Die Eingabe erfolgt in der Form "wert/wert"
# Awk trennt dies in '$min/$max',
# '$opt1' und '$opt2' sind die gesamte Option incl. Wert.
opt1=''
opt2=''
if [ -n "$wahl" ] ; then
min=$(echo $wahl | awk 'BEGIN { FS = "/" }
{ print $1 }')
max=$(echo $wahl | awk 'BEGIN { FS = "/" }
{ print $2 }')
# Es werden die Optionen gesetzt (s.U.):
if [ ! "$min" = "0" ] ; then
opt1="-ctime +$min"
fi
if [ ! "$max" = "0" ] ; then
opt2="-ctime -$max"
fi
# Hier wird erstmal geprüft, ob der gewählte Zeitraum
# eine Dateiauswahl enthält:
if [ -z "$( find $opt0 $opt1 $opt2 )" ] ; then
echo -e $rot'\n > kein Suchergebnis'$def
fi
# In jedem Fall wird angeboten, die Zeitraumauswahl
# zu wiederholen:
find $opt0 $opt1 $opt2
echo -n -e $blau'\n back=[y] > '$def
read time
# 'return 2' wird veranlassen, daß die Funktion 'Time'
# erneut ausgeführt wird:
if [ "$time" = "y" ] ; then
return 2
fi
fi
# Das Ende der Funktion:
}
Time ""
# Solange hier 'return 2' ankommt, wird wiederholt:
while [ $? = "2" ] ; do Time "" ; done
#X# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#######################
# FIND-OPTION: CMIN #
#######################
# Ist absolut identisch mit der obigen Funktion 'Time',
# nur das '-ctime' '-cmin' ersetzt.
Min () {
echo -e $rot'______________________'
echo -e ' Der Inhalt wurde vor min/max Minuten veraendert:'
echo -e -n $blau' weiter=[] > '$def
read wahl
opt1=''
opt2=''
if [ -n "$wahl" ] ; then
min=$(echo $wahl | awk 'BEGIN { FS = "/" }
{ print $1 }')
max=$(echo $wahl | awk 'BEGIN { FS = "/" }
{ print $2 }')
# AWK trennt die beiden Werte zB "0/10" anhand des Trenners "/"
# Da aber 'find' nicht mit dem Wert '0' umgeht, wird in dem Fall
# die ganze Option weggelassen (was das gewünschte Ergebnis bringt)
# Das ändert nichts daran, daß obiges AWK beide Werte verlangt!
if [ ! "$min" = "0" ] ; then
opt1="-cmin +$min"
fi
if [ ! "$max" = "0" ] ; then
opt2="-cmin -$max"
fi
if [ -z "$( find $opt0 $opt1 $opt2 )" ] ; then
echo -e $rot'\n > kein Suchergebnis'$def
fi
find $opt0 $opt1 $opt2
echo -n -e $blau'\n back=[y] > '$def
read time
if [ "$time" = "y" ] ; then
return 2
fi
fi
# Ende der Funktion 'Min':
}
Min ""
while [ $? = "2" ] ; do Min "" ; done
#X# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
########################
# FIND-OPTION: REGEX #
########################
# 'REG' wird am Ende der Funktion ausgewertet,
# um ggF die Funkion erneut aufzurufen.
REG='1'
Regex () {
echo -e $rot'______________________'
echo -e ' der Pfadname passt auf Regex:'
echo -e -n $blau' alle=[] > '$def
read wahl
opt3='.*'
# Wenn $wahl leer ist, ist der Regex ".*" (also alle),
# wenn nicht, wird der gewählte Wert genommen.
if [ -n "$wahl" ] ; then
opt3="$wahl"
fi
# Hier werden alle zuvor gewählten Find-Optionen ausgeführt
# und das Ergebnis in der temporären Datei $tmp gespeichert:
############################################
find $opt0 $opt1 $opt2 -regex "$opt3" > $tmp
############################################
cat $tmp
# Falls diese Optionen keine passenden Dateien finden,
# wird dies hier ausgegeben:
if [ -z "$(cat $tmp)" ] ; then
echo -e $rot'\n > kein Suchergebnis'$def
fi
# So oder so wird angeboten, die Funktion Regex erneut
# aufzurufen:
echo -e $rot'______________________'
echo -e ' Regex wiederholen ?'
echo -e -n $blau' nein=[] > '$def
read REG
# 'return 2' veranlasst den Wiederaufruf:
if [ -n "$REG" ] ; then return 2 ; fi
# Hier ist die Funktion 'Regex' zu Ende:
}
Regex ""
while [ $? = "2" ] ; do Regex "" ; done
# Die Idee, am Ende der Dateivorauswahl nochmal einen Schritt
# zurück zum Anfang des Scriptes zu ermöglichen, ist mir erst
# später gekommen. Darum wird das hier durch einen komplett
# neuen Aufruf (Option -repeat) gelöst:
echo -e $rot'\n Die Vorauswahl verwerfen ? [y]'
echo -n -e $blau' weiter=[] > '$def
read REPEAT
if [ "$REPEAT" = "y" ] ; then
FIND -repeat
exit 0
fi
# Wenn die bereits oben in '$tmp' gespeichert Ausgabe von 'Find'
# eine Auswahl der im Verzeichnis vorhandenen Dateien erbracht
# hat (also nicht mit dem Inhalt übereinstimmt), wird dies
# hier ausgegeben:
if [ ! "$(cat $tmp)" = "$(find)" ] ; then
echo -e $rot'\n Auswahl ist gespeichert !'$def
fi
##
fi
##
####################################################
# ACHTUNG, HIER IST DAS ENDE DER DATEIVORAUSWAHL #
####################################################
# OK, wurde am Anfang gewünscht, daß keine Dateivorauswahl
# stattfindet, wird alles genommen:
if [ "$VERZ" = "y" ] ; then
###########
find > $tmp
###########
# Eine Warnung wird ausgegeben:
echo -e $rot'\n VORSICHT: Alle Dateien und Verzeichnisse unterhalb\n '$def'> '`pwd`\
$rot'\n werden bearbeitet !'$def
fi
#X# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#########################
# BEGINN DER AKTIONEN #
#########################
# Diese, erste, Aktionsauswahl wir als Funktion geführt,
# weil die Wahl von 4) mv dazu führt, daß die in $tmp abgelegte
# Dateivorauswahl gelöscht wird (genaugenommen gibt´s keine
# Möglichkeit, nach der Wahl von 'mv' zu den Aktionen 1-3
# zurückzukehren).
Akt0 () {
echo -e $rot
cat <<!
______________________
AKTIONEN:
1) egrep
2) sed
3) rm/cp
4) mv
!
echo -e -n $blau' quit=[] > '$def
# "quit" wird nicht ausdrücklich ausgeführt, es gibt aber im
# Script keinen weiteren Code (ausser den benannten Aktionen).
read WAHL
# Dateivorauswahl:
# Wenn also "4) mv" gewählt wurde...
if [ "$WAHL" = "4" ] ; then
# ..und es überhaupt etwas zu verwerfen gibt..
if [ ! "$(cat $tmp)" = "$(find)" ] ; then
# wird angeboten, zur 'Aktionen' zurückzukehren (durch 'return 2'):
echo -e $rot '\n Die Vorauswahl verwerfen ? [y]'
echo -e -n $blau' back=[] > '$def
read wahl
if [ ! "$wahl" = "y" ] ; then
return 2
fi
fi
fi
# Und hier ist die Funktion zu Ende:
}
Akt0 ""
while [ $? = "2" ] ; do Akt0 "" ; done
#X# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
###################
# AKTION: EGREP #
###################
if [ "$WAHL" = "1" ] ; then
EGR='1'
Egrep () {
echo -e $rot
cat <<!
______________________
EGREP-OPTIONEN:
-v Zeilen, die den Ausdruck nicht enthalten
-w der Ausdruck als komplettes Wort
-x der Ausdruck als ganze Zeile
-n 'n' Zeilen Kontext
!
echo -e -n $blau"\n[-o] 'regex'> "$def
read wahl
# OPT: "alles was zwischen '...' steht, wird entfernt"
# Das ist also ggF die Option.
#
# REG: Alles vom Anfang bis incl. dem ersten "'" wird entfernt;
# danach noch das zweite "'". Übrig bleibt der Regex.
opt=`echo $wahl | sed "s|'.*'||"`
reg=`echo $wahl | sed "s|^[^']*'||" | sed "s|'$||"`
# Da unser Regex den Text durchsuchen soll, können Verzeichnisse
# ausgeschlossen werden: "if [ -f $i ] ; then..."
for i in `cat $tmp` ; do
if [ -f $i ] ; then
ausg=`egrep $opt "$reg" $i`
# Wenn die Ausgabe von 'egrep' ein Ergebnis bringt, gib dieses
# aus. Dabei kann nicht einfach 'echo $ausg' genommen werden,
# weil dann die ganze Augabe in einer langen Zeile erfolgen
# würde:
if [ -n "$ausg" ] ; then
echo -e '______________________\n'$i':'
egrep $opt "$reg" $i
fi
fi
done
# Dieser Vorgang kann erneut mit anderen Vorgaben ausgeführt
# werden:
echo -e $rot'______________________'
echo ' Egrep wiederholen ?'
echo -e -n $blau' nein=[] > '$def
read EGR
if [ -n "$EGR" ] ; then return 2 ; fi
# Ende der Funktion:
}
Egrep ""
while [ $? = "2" ] ; do Egrep "" ; done
# Trotzdem ist man hier mit 'EGREP' noch nicht am Ende,
# da ja die Dateivorauswahl noch immer zur Verfügung steht
# und also noch für "sed" und "rm/mv" genutzt werden kann.
# Um aber bei Auswahl von "4) mv" ggF. die Auswahl erneut
# aufrufen zu können, wird sie wieder als Funktion ausgeführt.
Akt1 () {
echo -e $rot
cat <<!
______________________
AKTIONEN:
1) -
2) sed
3) rm/cp
4) mv
!
echo -e -n $blau' quit=[] > '$def
read WAHL
if [ "$WAHL" = "4" ] ; then
if [ ! "$(cat $tmp)" = "$(find)" ] ; then
echo -e $rot '\n Die Vorauswahl verwerfen ? [y]'
echo -e -n $blau' back=[] > '$def
read wahl
if [ ! "$wahl" = "y" ] ; then
return 2
fi
fi
fi
# Ende der Funktion:
}
Akt1 ""
while [ $? = "2" ] ; do Akt1 "" ; done
fi
#X# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#################
# AKTION: SED #
#################
if [ "$WAHL" = "2" ] ; then
Sed () {
# Erleuterung zu SED:
echo -e $rot
cat <<!
______________________
SED-MUSTER:
^ = Zeilenanfang
$ = Zeilenende
.* = beliebig viele Zeichen
.+ = mindestens eins
[a-z] = Zeichenklasse
[^0-9] = Komplementklasse
\\\n = neue Zeile
\\\. = Escape (also ".")
!
echo '______________________'
# Das Suchmuster "$expr0":
echo -e -n $blau' regex > '$def
read expr0
# Das Ersatzmuster "$expr1":
echo -n -e $blau' sed s'$rot'|'$blau$expr0$rot'|'$def
read expr1
# Das Ganze anzeigen:
echo -e $blau' sed s'$rot'|'$blau$expr0$rot'|'$blau$expr1$rot'|'$blau'g\n'
echo -e $rot ' EDIT: [y] neuer Ausdruck: [x]'
echo -e -n $blau' cancel=[] > '$def
read wahl
# Wenn editiert werden soll,
# nimm jeden Eintrag aus der Dateivorauswahl...
if [ "$wahl" = "y" ] ; then
for i in `cat $tmp` ; do
# Wenn das Suchmuster "$expr0" in der zugehörigen Datei
# vorkommt ('egrep -l' gibt nur den Dateinamen aus), lege eine
# "Dateinamen.sedbak" an.
if [ "$i" = "$( egrep -l $expr0 $i )" ] ; then
# ...und editiere in die Originaldatei:
cp $i $i.sedbak
sed 's|'$expr0'|'$expr1'|g' $i.sedbak > $i
fi
done
# Ein Leichtes, ersteinmal alle editierten Dateien
# auszugeben (alle, für die eine "Datei.sedbak" existiert):
echo -e $rot'______________________'
echo -e ' Folgende Dateien wurden editiert:\n'$def
find -name '*.sedbak' | sed 's|.sedbak||g'
# Angeboten wird:
# Sed erneut aufrufen über 'return 2'
# 'Undo' durch rückkopieren von *.sedback zum Original
# Die Funktion "Sed" verlassen.
echo -e $rot '\n Sed erneut aufrufen: [x] Undo: [z]'
echo -e -n $blau' weiter=[] > '$def
read wahl
# Wenn 'Undo' gewählt wurde, suche alle editierten Dateien,
# und kopiere: 'cp Datei.sedbak Datei'
if [ "$wahl" = "z" ] ; then
for i in `find -name '*.sedbak' | sed 's|.sedbak||g'` ; do
cp $i.sedbak $i
done
wahl="x" # Funktion erneut aufrufen
fi
# Unabhängig davon, ob 'Undo' ausgeführt wurde oder nicht,
# werden jedenfalls danach alle Dateien mit der Endung '.sedbak'
# wieder entfernt:
for i in `find -name '*.sedbak'` ; do
rm $i
done
fi
# Die Option, Sed erneut aufzurufen, konnte ganz am Anfang
# der Funktion gewählt werden (um neue Muster zu definieren),
# aber auch nach dem Editieren:
# Jedesmal aber ist '$wahl'= "x".
if [ "$wahl" = "x" ] ; then return 2 ; fi
# Ende der Funktion:
}
Sed ""
while [ $? = "2" ] ; do Sed "" ; done
# Um bei Auswahl von "4) mv" ggF. die Auswahl erneut aufrufen
# zu können, wird sie wie bei den Vorherigen auch, als Funktion
# ausgeführt:
Akt2 () {
echo -e $rot
cat <<!
______________________
AKTIONEN:
1) -
2) -
3) rm/cp
4) mv
!
echo -e -n $blau' quit=[] > '$def
read WAHL
if [ "$WAHL" = "4" ] ; then
if [ ! "$(cat $tmp)" = "$(find)" ] ; then
echo -e $rot '\n Die Vorauswahl verwerfen ? [y]'
echo -e -n $blau' back=[] > '$def
read wahl
if [ ! "$wahl" = "y" ] ; then
return 2
fi
fi
fi
# Ende der Funktion:
}
Akt2 ""
while [ $? = "2" ] ; do Akt2 "" ; done
fi
#X# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
###################
# AKTION: RM/CP #
###################
if [ "$WAHL" = "3" ] ; then
RmCp () {
# Angeboten wird:
# die Dateivorauswahl weiter einschränken.
# 'find' und 'egrep' zu überspringen.
# die ganze Aktion zu canceln.
echo -e $rot'______________________'$def
cat $tmp
echo -e $rot'______________________'
echo -e ' RM/CP weiter=[y] cancel=[c] alles=[]\n MUSTER + TEXTSUCHE:\n'$def
echo -e -n $blau"find 'regex'> "$def
read expr0
# Wenn 'rm/cp' nicht gecancelt wird:
if [ ! "$expr0" = "c" ] ; then
# und 'find' und 'egrep' nicht übersprungen werden:
if [ ! "$expr0" = "y" ] ; then
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Wird also das 'find-Muster' ausgewertet.
# Ist das 'find-Muster' aber leer, soll _alles_ durch Find
# gefunden werden.
# Nun sollte man denken, .* würde genügen; dem ist aber nicht
# so:
echo ''
if [ -z "$expr0" -o "$expr0" = ".*" ] ; then
expr0="^.*$"
fi
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Nun wird erstmal das Ergebnis der Find-Suche ausgegeben;
# Da wir aber mit der Vorauswahl-List arbeiten, kommt 'egrep -x'
# (-x = ganze Zeile) zum Einsatz:
if [ -z "$( cat $tmp | egrep -x $expr0 )" ] ; then
echo -e $rot' > kein Suchergebnis'$def
fi
for i in `cat $tmp | egrep -x $expr0` ; do
echo $i
done
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Dann kommt die weiter Einschränkung durch Egrep:
# Auch hier wird eine leere Eingabe als 'alles' gewertet:
echo -n -e $blau"\ngrep 'regex'> "$def
read expr1
if [ -z "$expr1" ] ; then expr1='^.*' ; fi
# UND JETZT BEIDES:
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
echo ''
FILE='' # Dies muß _vor_ der 'for-Schleife' geschehen!
for i in `cat $tmp | egrep -x $expr0` ; do
# Wenn $i eine Datei ist, prüfe ob sie den Ausdruck
# '$expr1' enthält:
if [ -f "$i" ] ; then
# Da wir keine weitere temporäre Datei anfangen wollen,
# wird die Auswahl in das Array 'file' geschrieben:
if [ -n "$( cat $i | egrep $expr1 )" ] ; then
FILE=$FILE' '$i
fi
fi
done
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Das Array 'FILE' wird in '$tmp' geschrieben.
# Vorher aber muß der alte Inhalt von $tmp 'gerettet' werden,
# falls weiter unten das löschen/kopieren verworfen wird:
TMP=''
for i in `cat $tmp` ; do
TMP=$TMP' '$i
done
echo -n '' > $tmp
for i in $FILE ; do
echo $i >> $tmp
done
# Hier wird endlich das Ergebnis der kombinierten Suche ausgegeben:
if [ -z "$( cat $tmp )" ] ; then
echo -e $rot' > keine Suchergebnis'$def
fi
cat $tmp
fi
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Wurde oben die Option 'weiter [y]' gewählt, kommt man hier an.
#
# Zur Auswahl steht:
# löschen [x]
# kopieren [c]
# den Vorgang abbrechen, weil man mit der soeben ausgegebenen
# Dateiauswahl nicht einverstanden ist.
echo -e $rot '\n DEL=[x] COPY=[c]'
echo -e -n $blau' back=[] > '$def
read wahl
case "$wahl" in
# LÖSCHEN:
# Für jede in der Datei $tmp gelisteten Datei führe rekursives
# löschen durch (es können Verzeichnisse dabei sein).
# Es wird aber nochmal nachgefragt; wird hier nicht bestätigt,
# wird durch 'return 2' die ganze Funktion am Ende neu aufgerufen.
x) echo -e $rot ' loesche alle oben gelisteten Dateien ? [yes]'
echo -e -n $blau' no=[] > '$def
read del
if [ "$del" = "yes" ] ; then
for i in `cat $tmp` ; do
rm -r $i
done
else
return 2
fi
;;
# KOPIEREN:
# Zunächst muß ein Ziel (ein Verzeichnis) eingegeben werden,
# in das hinein kopiert werden soll:
c) echo -n -e $blau'\n ZIEL > '$def
read wahl
dir=`echo $wahl | sed "s|^~|$HOME|g"`
# Wenn das angegebene Ziel ein vorhandenes Verzeichnis ist, kopiere
# (genau wie bei 'rm' rekursiv) in das Zielverzeichnis:
if [ -d "$dir" ] ; then
for i in `cat $tmp` ; do
cp -r $i $dir
done
# Wenn das angegebene Ziel _kein_ vorhandenes Verzeichnis ist:
else
if [ -n "$( echo $dir | egrep '^~?/.+' )" ] ; then
# Wenn die Eingabe der Form "~/.." oder "/.."
# entspricht, biete an, das Verzeichnis anzulegen:
echo -e $rot' Das angegebene Verzeichnis existiert nicht!\n'$def
echo -e $dir $rot' jetzt Anlegen ? [y]'
echo -e -n $blau' weiter=[] > '$def
read mkdir
# Wenn also angelegt werden soll, lege an:
if [ "$mkdir" = "y" ] ; then
mkdir $dir
else
echo -n -e $blau' \nZIEL > '$def
read wahl
fi
# Sonst wird noch ein zweites Mal nachgefragt:
else
echo -e $rot ' Das angegebene Ziel ist kein Verzeichnis !\n'
echo -e -n $blau' ZIEL > '$def
read wahl
fi
# Dann versuche also erneut, zu kopieren.
# Ist das angegebene Ziel wieder nicht auffinbar, wird der Vorgang
# abgebrochen und die Funktion erneut aufgerufen:
dir=`echo $wahl | sed "s|^~|$HOME|g"`
if [ -d "$dir" ] ; then
for i in `cat $tmp` ; do
cp -r $i $dir
done
else
echo -e $rot' Das angegebene Ziel ist kein Verzeichnis !!'$def
return 2
fi
fi
;;
# Wurde gewählt, weder zu kopieren noch zu löschen (Leereingabe)
# kommt hier wieder 'return 2' zum Zug:
# Dann soll allerdings auch der alte Zustand von "$tmp" wieder
# hergestellt sein:
*) echo -n '' > $tmp
for i in $TMP ; do
echo $i >> $tmp
done
return 2
;;
esac
fi
# Da nur noch die Aktion 'mv' übrigbleibt, kann jetzt die
# Dateivorauswahl verworfen werden - aber nur, wenn sie sich
# vom Verzeichnisinhalt unterscheidet.
# Es gab ja auch die Möglichkeit, die Dateivorauswahl zu übergehen.
echo -e $rot
cat <<!
______________________
AKTIONEN:
1) -
2) -
3) -
4) mv
!
echo -e -n $blau' quit=[] > '$def
read WAHL
if [ "$WAHL" = "4" ] ; then
if [ ! "$(cat $tmp)" = "$(find)" ] ; then
echo -e $rot'\n Die Vorauswahl wird verworfen !'$def
fi
fi
# Hier ist die Funktion 'RmCp' zu Ende:
}
RmCp ""
while [ $? = "2" ] ; do RmCp "" ; done
fi
#X# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
################
# AKTION: MV #
################
if [ "$WAHL" = "4" ] ; then
Mv () {
echo -e $rot'______________________'$def
find
echo -e $rot'______________________'
echo -e '" MV SUCHMUSTER ERSATZMUSTER ", Verzeichnisse werden angelegt:'
echo -e -n $blau' MUSTER > '$def
read expr0
# Wenn die Suchmustereingabe leer bleibt,
# wird angeboten, das Programm zu verlassen.
# Sonst wird halt neu gefragt:
if [ -z "$expr0" ] ; then
echo -e -n $blau' quit=[] > '$def
read wahl
if [ -z "$wahl" ] ; then
exit 0
else
return 2
fi
fi
# Nach der Ersatzmustereingabe wird ersteinmal das Ergebnis
# der Ersetzung ausgegeben:
echo -e -n $blau' ERSATZ > '$def
read expr1
find | sed "s|$expr0|$expr1|g"
# Nun muß geprüft werden, ob die Änderungen in der Pfadangabe
# das Anlegen neuer Verzeichnisse erforderlich machen würde:
for i in `find -type d | sed "s|$expr0|$expr1|g"` ; do
# Nimm also alle Verzeichnisse, wende den Audruck an, und prüfe
# für jeden Teil des Pfades, ob das angegebene Verzeichnis
# tatsächlich existiert. Dazu wird bei jedem Schleifendurchlauf
# "/name" vom Ende des Pfades abgezogen bis nur noch der Punkt "."
# übrigbleibt, den Find stets mit ausgibt.
dir=$i
# Solange der Pfadname noch nicht auf "." reduziert ist...
while [ ! $dir = "." ] ; do
# prüfe, ob es sich um ein Verzeichnis handelt.
# Wenn nicht...
if [ ! -d $dir ] ; then
# ..frage nach, ob es angelegt werden soll.
# bleibt die Eingabe leer, passiert halt nichts:
echo -e $rot'______________________'
echo -e $dir ' existiert nicht. Anlegen ? [y]'
echo -e -n $blau' cancel=[] > '$def
read do
# Wir aber mit [y] bestätigt, lege an!
if [ "$do" = "y" ] ; then
mkdir -p $dir
fi
fi
# Dann ziehe vom Ende des Pfades "/name" ab, und prüfe erneut:
dir=$( echo $dir | sed 's|/[^/]*$||' )
done
done
# Nun sollten also alle neuen Verzeichnisse angelegt sein,
# die Dateien befinden sich aber noch in den alten.
# Es wird gefragt, ob sie nun verschoben werden sollen:
echo -e $rot'______________________'
echo -e ' Move ? [y]'
echo -e -n $blau' cancel=[] > '$def
read wahl
# Bleibt die Eingabe leer, passiert halt nichts.
# Wenn das Verschieben bestätigt wird:
if [ "$wahl" = "y" ] ; then
# Nimm alle Dateien, auf die das Suchmuster '$expr0' passt.
# 'find -depth' bewirkt, das immer der Inhalt eines Verzeichnisses
# zuerst ausgegeben wird:
for i in `find -depth -type f | egrep $expr0` ; do
# Für alle Dateien, auf die das Suchmuster passt, wird also
# der Pfad angepasst und 'mv' ausgeführt.
# Natürlich setzt das vorraus, daß Verzeichnisse, in die
# verschoben werden soll, bereits vorhanden sind (s.o.).
neu=$( echo $i | sed "s|$expr0|$expr1|g" )
mv $i $neu
done
# Nun werden wiederum alle Verzeichnisse, die von Namensänderungen
# betroffen waren, herausgesucht. Es wird geprüft, ob sie leer
# sind (sollten sie nach dem Verschieben der Dateien ja),
# und ggF werden sie gelöscht.
# Damit ist das Umbenennen abgeschlossen:
for i in `find -depth -type d | egrep $expr0` ; do
if [ -z "$(ls $i)" ] ; then
rm -r $i
fi
done
fi
echo -e '\n mv wiederholen ?'
echo -e -n $blau' nein=[] > '$def
read EGR
if [ -n "$EGR" ] ; then return 2 ; fi
# Ender der Funktion 'Mv':
}
# Solange wiederholen von 'Mv' gewünsch ist (return 2):
Mv ""
while [ $? = "2" ] ; do Mv "" ; done
fi
# Ende des Scriptes.
echo '======================'
exit 0
#X####################################### FIN ###################################################