fileedit.c-Dateireferenz

#include <wizlevels.h>
#include <magier.h>
#include <player.h>
Include-Abhängigkeitsdiagramm für fileedit.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define NEED_PROTOTYPES

Funktionen

mixed * _query_localcmds ()
private void _ed_file ()
private mixed _ed_size_filter (mixed *arg)
static int _ed (string cmdline)
static void _cp_ask_copy (mixed *filedata, int dummy, int flags)
static void _cp_ask_overwrite (mixed *filedata, int mode, int flags)
static void _mv_ask_overwrite (mixed *filedata, int mode, int flags)
static mixed cp_file (mixed filedata, int move, int flags, mixed *do_delete)
static void _cp_ask_overwrite2 (string input, mixed *filedata, int interactive, int flags, int move)
static void _cp_ask_copy2 (string input, mixed *filedata, int mode, int flags, int move)
static int _cp (string cmdline)
private int _dir_filter (mixed arg)
static int _rmdir (string cmdline)
static int _mkdir (string cmdline)
private void _rm_ask_delete (mixed *filedata, int flags)
static void _rm_ask_delete2 (string input, mixed *filedata, int flags)
private void rm_file (mixed filedata, mixed notused, int flags)
static int _rm (string cmdline)

Variablen

static private string * _ed_cache

Makro-Dokumentation

#define NEED_PROTOTYPES

Definiert in Zeile 13 der Datei fileedit.c.

Dokumentation der Funktionen

static int _cp ( string  cmdline  )  [static]

Definiert in Zeile 369 der Datei fileedit.c.

Benutzt _unparsed_args(), cp_file(), CP_M, CP_OPTS, dest(), notify_fail(), parseargs(), to_filename() und USAGE.

00370 {
00371   mixed *args;
00372   int flags;
00373   string mask;
00374   string dest,*dest2;
00375   cmdline=_unparsed_args();
00376   args=parseargs(cmdline,&flags,CP_OPTS,0);
00377   if (flags==-1||!sizeof(args))
00378     return USAGE(query_verb()+" [-" CP_OPTS
00379                  "] <datei/verz> [<datei2/verz2> ... ] <ziel> [<maske>]");
00380   if (flags&CP_M)
00381   {
00382     mask=args[<1];
00383     args=args[0..<2];
00384   }
00385   if (!dest=to_filename(args[<1]))
00386      return USAGE(query_verb()+" [-" CP_OPTS
00387           "] <datei/verz> [<datei2/verz2> ... ] <ziel> [<maske>]");
00388   if (file_size(dest)==-1)
00389   {
00390     dest2=explode(dest,"/");
00391     if (file_size(implode(dest2[0..<2],"/"))==-2)
00392     {
00393       if (dest2[<1]=="*")
00394         dest=implode(dest2[0..<2],"/");
00395       else
00396         if (member(dest2[<1],'*')>-1||
00397             member(dest2[<1],'?')>-1)
00398          return notify_fail(
00399           sprintf("%s: Keine * und ? im Zielnamen erlaubt.\n",query_verb())),0;
00400     }
00401     else
00402       return notify_fail(
00403         sprintf("%s: Der angegebene Zielpfad existiert nicht.\n",
00404                 query_verb())),0;
00405   }
00406   args=args[0..<2];
00407   if (file_size(dest)!=-2&&sizeof(args)>1)
00408     return notify_fail(
00409         sprintf("%s: Bei mehreren Quellen muss das Ziel ein Verzeichnis "
00410                 "sein.\n",query_verb())),0;
00411   if (!sizeof(args=map(args,#'to_filename)-({0})))
00412     return USAGE(query_verb()+" [-" CP_OPTS
00413           "] <datei/verz> [<datei2/verz2> ... ] <ziel> [<maske>]");
00414   // DEBUG("DEST: " + dest + " : FLAGS: " + flags);
00415   args=file_list(args,MODE_CP,(flags&CP_R),dest+"/",mask);
00416   if (!sizeof(args))
00417     return notify_fail(sprintf("%s: Keine passenden Dateien gefunden.\n",
00418                                query_verb())),0;
00419 
00420   if (sizeof(args)>1&&(args[0][FILESIZE]>=0)&&file_size(dest)!=-2)
00421       return notify_fail(
00422         sprintf("%s: Bei mehreren Quellen muss das Ziel ein Verzeichnis "
00423                 "sein.\n",query_verb())),0;
00424   if (sizeof(args)==1&&file_size(dest)!=-2)
00425     args[0][DESTNAME]=dest;
00426   if (!(flags&CP_I))
00427   {
00428     asynchron(args,#'cp_file,(query_verb()=="mv"),flags,0);
00429     return 1;
00430   }
00431   if (query_verb()=="cp")
00432     _cp_ask_copy(args,0,flags);
00433   else
00434     _cp_ask_copy(args,1,flags);
00435   return 1;
00436 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

static void _cp_ask_copy ( mixed *  filedata,
int  dummy,
int  flags 
) [static]

Definiert in Zeile 299 der Datei fileedit.c.

Benutzt data, dest(), DEST_IS_DIR, DOESNT_EXIST, FILESIZE, FULLNAME, input_to(), MAY_READ, MAY_WRITE, NO_DIRS, NO_READ, NO_WRITE, SAME_FILE und SUBDIRSIZE.

00300 {
00301   mixed data;
00302   string dest,source;
00303   int delete_subs,jump;
00304 
00305   if(!sizeof(filedata))
00306   {
00307     printf("%s: abgeschlossen.\n",move?"mv":"cp");
00308     return; 
00309   }
00310   dest=filedata[0][DESTNAME];
00311   source=filedata[0][FULLNAME];
00312   switch(0)   // break wirkt damit wie ein goto end_of_switch
00313   {
00314     default:
00315     case 0: // Sinnlos, aber er compiliert sonst nicht :(
00316       jump=filedata[0][SUBDIRSIZE];
00317       if (source==dest)
00318       {
00319         printf(SAME_FILE,source);
00320         break;
00321       }
00322       if (!MAY_READ(source))
00323       {
00324         printf(NO_READ,source);
00325         break;
00326       }
00327       if (!MAY_WRITE(dest))
00328       {
00329         printf(NO_WRITE,dest);
00330         jump=0;
00331         break;
00332       }
00333       if (filedata[0][FILESIZE]==-1)
00334       {
00335         printf(DOESNT_EXIST,source);
00336         break;
00337       }
00338       if (filedata[0][FILESIZE]==-2) // Quelle ist Verzeichnis
00339       {
00340         if (file_size(dest)>-1)
00341         {
00342           printf(NO_DIRS,dest);
00343           break;
00344         }
00345         if (file_size(dest)==-2)
00346         {
00347           jump=0;
00348           break;
00349         }
00350         printf("Verzeichnis '%s' %s? (j,n,a,q)\n",source,
00351                move?"bewegen":"kopieren");
00352         input_to("_cp_ask_copy2",0,filedata,2,flags,move);
00353         return;
00354       }
00355       if (file_size(dest)==-2)
00356       {
00357         printf(DEST_IS_DIR,dest);
00358         break;
00359       }
00360       printf("'%s' %s? (j,n,a,q)\n",source,move?"bewegen":"kopieren");
00361       input_to("_cp_ask_copy2",0,filedata,(file_size(dest)!=-1),flags,move);
00362       return;
00363   }
00364   _cp_ask_copy(filedata[1+jump..],move,flags);
00365   return;
00366 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

static void _cp_ask_copy2 ( string  input,
mixed *  filedata,
int  mode,
int  flags,
int  move 
) [static]

Definiert in Zeile 231 der Datei fileedit.c.

00233 {
00234   if (!strlen(input)) input=" ";
00235   input=lower_case(input);
00236   switch(input[0])
00237   {
00238     case 'y':
00239     case 'j':
00240       if (mode==1)
00241       {
00242         if (!(flags&CP_F))
00243         {
00244           if (move) _mv_ask_overwrite(filedata,1,flags);
00245           else      _cp_ask_overwrite(filedata,1,flags);
00246           return;
00247         }
00248         if (!rm(filedata[0][DESTNAME]))
00249         {
00250           printf(DEST_NO_DELETE "Uebergehe Datei...\n",
00251                  filedata[0][DESTNAME]);
00252           _cp_ask_copy(filedata[1..],move,flags);
00253           return;
00254         }
00255         if (flags&CP_V) printf(FILE_DELETED,filedata[0][DESTNAME]);
00256       }
00257       if (mode<2)
00258       {
00259         if (move) rename(filedata[0][FULLNAME],filedata[0][DESTNAME]);
00260         else copy_file(filedata[0][FULLNAME],filedata[0][DESTNAME]);
00261         _cp_ask_copy(filedata[1..],move,flags);
00262         return;
00263       }
00264       if (mode==2)
00265       {
00266         if (move)
00267         {
00268           if (rename(filedata[0][FULLNAME],filedata[0][DESTNAME]))
00269             printf(NO_MOVE "Uebergehe Verzeichnis...\n",
00270                    filedata[0][FULLNAME]);
00271           _cp_ask_copy(filedata[1+filedata[0][SUBDIRSIZE]..],move,flags);
00272           return;
00273         }
00274         if (mkdir(filedata[0][DESTNAME]))
00275         {
00276           _cp_ask_copy(filedata[1..],0,flags);
00277           return;
00278         }
00279         printf(NO_CREATE_DIR "Uebergehe Verzeichnis...\n",
00280                filedata[0][DESTNAME]);
00281       }
00282     case 'n':
00283       _cp_ask_copy(filedata[(1+filedata[0][SUBDIRSIZE])..],0,flags);
00284       return;
00285     case 'q':
00286       printf("Kopieren abgebrochen!\n");
00287       return;
00288     case 'a':
00289       flags&=~CP_I;
00290       asynchron(filedata,#'cp_file,move,flags,0);
00291       return;
00292     default:
00293       printf("Kommando nicht verstanden.\n");
00294       _cp_ask_copy(filedata,0,flags);
00295       return;
00296   }
00297 }

static void _cp_ask_overwrite ( mixed *  filedata,
int  mode,
int  flags 
) [static]

Definiert in Zeile 215 der Datei fileedit.c.

00216 {
00217   printf("Die Datei '%s' existiert schon. Ueberschreiben? (j,n,a,q)\n",
00218          filedata[0][DESTNAME]);
00219   input_to("_cp_ask_overwrite2",0,filedata,interactive,flags,0);
00220   return;
00221 }

static void _cp_ask_overwrite2 ( string  input,
mixed *  filedata,
int  interactive,
int  flags,
int  move 
) [static]

Definiert in Zeile 165 der Datei fileedit.c.

00167 {
00168   if (!strlen(input)) input=" ";
00169   input=lower_case(input);
00170   switch(input[0])
00171   {
00172     case 'q':
00173       printf("%s abgebrochen!\n",move?"Bewegen":"Kopieren");
00174       return;
00175     case 'a':
00176       flags|=CP_F;
00177       if (!(flags&CP_I))
00178       {
00179         asynchron(filedata,#'cp_file,move,flags,0);
00180         return;
00181       }
00182     case 'y':
00183     case 'j':
00184       if (!rm(filedata[0][DESTNAME]))
00185         printf(DEST_NO_DELETE "Uebergehe Datei...\n",filedata[0][DESTNAME]);
00186       else
00187       {
00188         if (flags&CP_V) printf(FILE_DELETED,filedata[0][DESTNAME]);
00189         if (move)
00190         {
00191           if (rename(filedata[0][FULLNAME],filedata[0][DESTNAME]))
00192             printf(NO_MOVE "Uebergehe Datei...\n",filedata[0][FULLNAME]);
00193         }
00194         else
00195         {
00196           if (copy_file(filedata[0][FULLNAME],filedata[0][DESTNAME]))
00197             printf(NO_COPY "Uebergehe Datei...\n",filedata[0][FULLNAME]);
00198         }
00199       }
00200     case 'n':
00201       if (flags&CP_I)
00202         _cp_ask_copy(filedata[1+filedata[0][SUBDIRSIZE]..],move,flags);
00203       else
00204         asynchron(filedata[1+filedata[0][SUBDIRSIZE]..],
00205                                      #'cp_file,move,flags,0);
00206       return;
00207     default:
00208       printf("Kommando nicht verstanden.\n");
00209       _cp_ask_overwrite(filedata,interactive,flags);
00210       return;
00211   }
00212 
00213 }

private int _dir_filter ( mixed  arg  ) 

Definiert in Zeile 451 der Datei fileedit.c.

Benutzt FILESIZE.

00452 {
00453   return (arg[FILESIZE]==-2);
00454 }

static int _ed ( string  cmdline  )  [static]

Definiert in Zeile 65 der Datei fileedit.c.

Benutzt _unparsed_args(), file_list(), flags, i, master, MODE_ED, parseargs() und USAGE.

00066 {
00067   mixed *args,*args2;
00068   int flags,i,arg_size;
00069   cmdline=_unparsed_args();
00070   args=parseargs(cmdline,&flags,"",1);
00071   if (flags==-1||!(arg_size=sizeof(args)))
00072     return USAGE("ed <datei> [<datei2>..]");
00073   while(arg_size--)
00074   {
00075     if (sizeof(args2=file_list(args[arg_size..arg_size],MODE_ED,0,"/")))
00076       args[arg_size..arg_size]=args2;
00077     else
00078       args[arg_size]=({ "" , -1, 0 , (string)
00079               call_other(master(),"_get_path",args[arg_size],
00080                   getuid())});
00081   }
00082 #if __VERSION__ < "3.2.9"
00083   args=map(args,#'_ed_size_filter)-({0});
00084 #else
00085   args=map(args,(:
00086           if ($1[FILESIZE]>=-1) return $1[FULLNAME];
00087           printf("%s ist ein Verzeichnis.\n",$1[FULLNAME]);
00088           return 0; :))-({0});
00089 #endif
00090   if (flags==-1||!sizeof(args)) return USAGE("ed <datei> [<datei2>..]");
00091   _ed_cache=args;
00092   _ed_file();
00093   return 1;
00094 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

private void _ed_file (  ) 

Definiert in Zeile 42 der Datei fileedit.c.

00043 {
00044   if (!sizeof(_ed_cache)) return;
00045   printf("ed: Naechste Datei: %s\n",_ed_cache[0]);
00046   ed(_ed_cache[0],"_ed_file");
00047   _ed_cache=_ed_cache[1..];
00048   return;
00049 }

private mixed _ed_size_filter ( mixed *  arg  ) 

Definiert in Zeile 52 der Datei fileedit.c.

Benutzt FILESIZE und FULLNAME.

00053 {
00054   if (arg[FILESIZE]>=-1) return arg[FULLNAME];
00055   printf("%s ist ein Verzeichnis.\n",arg[FULLNAME]);
00056   return 0;
00057 }

static int _mkdir ( string  cmdline  )  [static]

Definiert in Zeile 513 der Datei fileedit.c.

00514 {
00515   string dest,tmp;
00516   int flags,i;
00517   string *args;
00518   
00519   cmdline=_unparsed_args();
00520   args=parseargs(cmdline,&flags,MKDIR_OPTS,1);
00521   if (flags==-1) return 0;
00522   if (!sizeof(args))
00523     return USAGE("mkdir [-" MKDIR_OPTS "] <Verzeichnis>");
00524   if (sizeof(args)>1)
00525     return notify_fail("Mit 'mkdir' kann nur jeweils EIN Verzeichnis "
00526                        "erstellt werden.\n"),0;
00527   dest=args[0];
00528   if ((i=file_size(implode((args=explode(dest,"/"))[0..<2],"/")))==-2)
00529   {
00530     if (!mkdir(dest)) return ERROR(NO_CREATE_DIR,dest,1);
00531     if (flags&MKDIR_V) printf(DIR_CREATED,dest,1);
00532     return 1;
00533   }
00534   if (i==-1)
00535   {
00536     if (flags&MKDIR_R)
00537     { 
00538       for (i=1;i<sizeof(args);i++)
00539       {
00540         switch(file_size(implode(args[0..i],"/")))
00541         {
00542           case -2: continue;
00543           case -1: if (!mkdir(implode(args[0..i],"/"))) 
00544                      return ERROR(NO_CREATE_DIR,implode(args[0..i],"/"),1);
00545                    if (flags&MKDIR_V)
00546                      printf(DIR_CREATED,implode(args[0..i],"/"));
00547                    continue;
00548           default: return ERROR(ALREADY_EXISTS,implode(args[0..i],"/"),1);
00549         }
00550       }
00551       printf("mkdir: abgeschlossen.\n");
00552       return 1;
00553     }
00554     return ERROR(DOESNT_EXIST,implode(args[0..<2],"/"),1);
00555   }
00556   return ERROR(ALREADY_EXISTS,dest,1);
00557 }

static void _mv_ask_overwrite ( mixed *  filedata,
int  mode,
int  flags 
) [static]

Definiert in Zeile 223 der Datei fileedit.c.

00224 {
00225   printf("Die Datei '%s' existiert schon. Ueberschreiben? (j,n,a,q)\n",
00226          filedata[0][DESTNAME]);
00227   input_to("_cp_ask_overwrite2",0,filedata,interactive,flags,1);
00228   return;
00229 }

mixed* _query_localcmds (  ) 

Definiert in Zeile 21 der Datei fileedit.c.

Benutzt WIZARD_LVL.

00022 {
00023   return ({ ({"cp","_cp",0,WIZARD_LVL}),
00024             ({"mv","_cp",0,WIZARD_LVL}),
00025             ({"rm","_rm",0,WIZARD_LVL}),
00026             ({"rmdir","_rmdir",0,WIZARD_LVL}),
00027             ({"mkdir","_mkdir",0,WIZARD_LVL}),
00028             ({"ed","_ed",0,WIZARD_LVL})});
00029 }

static int _rm ( string  cmdline  )  [static]

Definiert in Zeile 677 der Datei fileedit.c.

00678 {
00679   mixed *args,*args2;
00680   int flags,i;
00681   string mask;
00682   
00683   cmdline=_unparsed_args();
00684   args=parseargs(cmdline,&flags,RM_OPTS,0);
00685   if (flags==-1||!sizeof(args))
00686     return USAGE("rm [-" RM_OPTS
00687                  "] <datei/verz> [<datei2/verz2> ... ] [<maske>]");
00688   if (flags&RM_M)
00689   {
00690     mask=args[<1];
00691     args=args[0..<2];
00692   }
00693   args=map(args,#'to_filename)-({0});
00694   args=file_list(args,MODE_RM,(flags&RM_R),"/",mask);
00695   if (!(i=sizeof(args)))
00696     return printf("Keine passende Datei gefunden.\n"),1;
00697   if (!(flags&RM_I))
00698   {
00699     if (i>1) // Umdrehen
00700     {
00701       mixed temp;
00702       i>>=1;
00703       while(i)
00704       {
00705         temp=args[<(i--)];
00706         args[<(i+1)]=args[i];
00707         args[i]=temp;
00708       }
00709     }
00710     asynchron(args,#'rm_file,args,flags,0);
00711     return 1;
00712   }
00713   _rm_ask_delete(args,flags);
00714   return 1;
00715 }

private void _rm_ask_delete ( mixed *  filedata,
int  flags 
)

Definiert in Zeile 613 der Datei fileedit.c.

00614 {
00615   int i;
00616   mixed temp;
00617   if (!sizeof(filedata))
00618   {
00619     printf("rm: abgeschlossen.\n");
00620     return;
00621   }
00622   switch(filedata[0][FILESIZE])
00623   {
00624     case -1:
00625       if (flags&RM_V) printf(DOESNT_EXIST,filedata[0][FULLNAME]);
00626       _rm_ask_delete(filedata[1..],flags);
00627       return;
00628     case -2:
00629       if (i=filedata[0][SUBDIRSIZE])
00630         printf("Ins Verzeichnis '%s' hinabsteigen? (j,n,q)\n",
00631           filedata[0][FULLNAME]);
00632       else
00633         printf("Verzeichnis '%s' loeschen? (j,n,q)\n",
00634                filedata[0][FULLNAME]);
00635       input_to("_rm_ask_delete2",0,filedata,flags);
00636       return;
00637     default:
00638       printf("'%s' loeschen? (j,n,q)\n",
00639          filedata[0][FULLNAME]);
00640       input_to("_rm_ask_delete2",0,filedata,flags);
00641       return;
00642   }
00643 }

static void _rm_ask_delete2 ( string  input,
mixed *  filedata,
int  flags 
) [static]

Definiert in Zeile 565 der Datei fileedit.c.

00566 {
00567   int i;
00568   if (!strlen(input)) input=" ";
00569   input=lower_case(input);
00570   switch(input[0])
00571   {
00572     case 'q':
00573       printf("Loeschen abgebrochen!\n");
00574       return;
00575     case 'y':
00576     case 'j':
00577       if (filedata[0][FILESIZE]==-2)
00578       {
00579         if (i=filedata[0][SUBDIRSIZE]) // Dir-Eintrag nach hinten schieben
00580         {
00581           mixed temp;
00582           int j;
00583           temp=filedata[0];
00584           temp[SUBDIRSIZE]=0;
00585           for(j=0;j<i;j++) filedata[j]=filedata[j+1];
00586           filedata[j]=temp;
00587           _rm_ask_delete(filedata,flags);
00588           return;
00589         }
00590         if (!rmdir(filedata[0][FULLNAME]))
00591           printf(NO_DELETE,filedata[0][FULLNAME]);
00592         else if (flags&RM_V) printf(FILE_DELETED,filedata[0][FULLNAME]);
00593       }
00594       else // Datei existiert
00595       {
00596         if (!rm(filedata[0][FULLNAME]))
00597           printf(DEST_NO_DELETE "Uebergehe Datei...\n",
00598                  filedata[0][FULLNAME]);
00599         else if (flags&RM_V) printf(FILE_DELETED,filedata[0][FULLNAME]);
00600         
00601       }
00602     case 'n':
00603       _rm_ask_delete(filedata[1+filedata[0][SUBDIRSIZE]..],flags);
00604       return;
00605     default:
00606       printf("Kommando nicht verstanden.\n");
00607       _rm_ask_delete(filedata,flags);
00608       return;
00609   }
00610   return;
00611 }

static int _rmdir ( string  cmdline  )  [static]

Definiert in Zeile 458 der Datei fileedit.c.

Benutzt _unparsed_args(), dest(), file_list(), MODE_RMDIR, notify_fail(), parseargs(), RMDIR_OPTS und USAGE.

00459 {
00460   string dest,tmp;
00461   int flags;
00462   mixed *args;
00463   
00464   cmdline=_unparsed_args();
00465   args=parseargs(cmdline,&flags,RMDIR_OPTS,1);
00466   if (flags==-1||!sizeof(args))
00467     return USAGE("rmdir [-" RMDIR_OPTS "] <Verzeichnis>");
00468   if (sizeof(args)>1)
00469     return
00470     notify_fail("Mit 'rmdir' kann nur jeweils EIN Verzeichnis geloescht "
00471          "werden.\nDer Befehl 'rm' bietet erweiterte Moeglichkeiten.\n"),0;
00472   dest=args[0];
00473   if (dest!="/")
00474   {
00475     args=file_list(({dest}),MODE_RMDIR,0,"/");
00476 #if __VERSION__ < "3.2.9"
00477     args=filter(args,#'_dir_filter);
00478 #else
00479     args=filter(args,(: ($1[FILESIZE]==-2) :));
00480 #endif
00481     if (!sizeof(args))
00482       return notify_fail(
00483         sprintf("rmdir: %s: Kein solches Verzeichnis gefunden.\n",dest)),0;
00484     if (sizeof(args)>1)
00485       return notify_fail(
00486                 sprintf("rmdir: %s: Maske ist nicht eindeutig.\n",dest)),0;
00487     dest=args[0][FULLNAME];
00488     if (!MAY_WRITE(dest)) return ERROR(NO_WRITE,dest,1);
00489     if (!rmdir(dest))
00490     {
00491       if (sizeof((get_dir(dest+"/*")||({}))-({".",".."})))
00492         printf("rmdir: %s: Verzeichnis ist nicht leer.\n",dest);
00493     }
00494     else
00495     {
00496       if (flags&&RMDIR_V) printf(FILE_DELETED,dest);
00497     }
00498     return 1;
00499   }
00500   return ERROR(NO_DELETE,dest,1);
00501 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

static mixed cp_file ( mixed  filedata,
int  move,
int  flags,
mixed *  do_delete 
) [static]

Definiert in Zeile 105 der Datei fileedit.c.

Wird benutzt von _cp().

00106 {
00107   string source,dest;
00108   source=(string)filedata[FULLNAME];
00109   dest=(string)filedata[DESTNAME];
00110   if (source==dest) return ERROR(SAME_FILE,source,RET_FAIL);
00111   if (!MAY_READ(source)) return ERROR(NO_READ,source,RET_JUMP);
00112   if (!MAY_WRITE(dest)) return ERROR(NO_WRITE,dest,RET_JUMP);
00113   if (filedata[FILESIZE]==-1) return ERROR(DOESNT_EXIST,source,RET_JUMP);
00114   if (filedata[FILESIZE]==-2) // Quelle ist Verzeichnis
00115   {
00116     switch(file_size(dest))
00117     {
00118       case -1:
00119         if (move)
00120         {
00121           if (rename(source,dest)) return ERROR(NO_CREATE_DIR,dest,RET_JUMP);
00122           if (flags&CP_V) printf(FILE_MOVED,source);
00123           return RET_JUMP;
00124         }
00125         if (!mkdir(dest)) return ERROR(NO_CREATE_DIR,dest,RET_JUMP);
00126         if (flags&CP_V) printf(DIR_CREATED,dest);
00127       case -2:
00128         if (!move) return RET_OK;
00129         if (filedata[SUBDIRSIZE]>0) return RET_DELETE;
00130         if (!rmdir(source)) return ERROR(NO_DELETE,source,RET_FAIL);
00131         if (flags&MV_V) printf("mv: %s: Quellverzeichnis wurde "
00132                                "geloescht.\n",source);
00133         return RET_OK;    
00134       default:  return ERROR(NO_DIRS,dest,RET_JUMP);
00135     }
00136   }
00137   switch(file_size(dest))
00138   {
00139     case -2: return ERROR(DEST_IS_DIR,dest,RET_FAIL);
00140     default:
00141       if (flags&CP_F)
00142       {
00143         if (!rm(dest)) return ERROR(DEST_NO_DELETE,dest,RET_FAIL);
00144         if (flags&CP_V) printf(FILE_DELETED,dest);
00145       }
00146       else
00147       {
00148         if (move) return #'_mv_ask_overwrite;
00149         else return #'_cp_ask_overwrite;
00150       }
00151     case -1:
00152       if (move)
00153       {
00154         if (rename(source,dest)) return ERROR(NO_MOVE,source,RET_FAIL);
00155         if (flags&CP_V) printf(FILE_MOVED,source);
00156         return RET_OK;
00157       }
00158       if (copy_file(source,dest)) return ERROR(NO_COPY,source,RET_FAIL);
00159       if (flags&CP_V) printf(FILE_COPIED,source);
00160       return RET_OK;
00161   }
00162   return 0; // not-reached
00163 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

private void rm_file ( mixed  filedata,
mixed  notused,
int  flags 
)

Definiert in Zeile 646 der Datei fileedit.c.

00647 {
00648   string dest;
00649   dest=filedata[FULLNAME];
00650   if (!MAY_WRITE(dest))
00651   {
00652     printf(NO_WRITE,dest);
00653     return;
00654   }
00655   switch(filedata[FILESIZE])
00656   {
00657     case -1:
00658       if (flags&RM_V) printf(DOESNT_EXIST,dest);
00659       return;
00660     case -2:
00661       if (!rmdir(dest)) printf(DEST_NO_DELETE,dest);
00662       else
00663       {
00664         if (flags&RM_V) printf(FILE_DELETED,dest);
00665       }
00666       return;
00667     default:
00668       if (!rm(dest)) printf(DEST_NO_DELETE,dest);
00669       else
00670       {
00671         if (flags&RM_V) printf(FILE_DELETED,dest);
00672       }
00673       return;
00674   }
00675 }

Variablen-Dokumentation

private string* _ed_cache [static]

Definiert in Zeile 40 der Datei fileedit.c.

Erzeugt am Thu Jun 3 14:43:13 2010 für MorgenGrauen Mudlib von  doxygen 1.6.3