parsing.c-Dateireferenz

#include <files.h>
#include <wizlevels.h>
#include <logging.h>
#include <magier.h>
#include <thing/properties.h>
#include <player.h>

Include-Abhängigkeitsdiagramm für parsing.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	NEED_PROTOTYPES
Funktionen
static string	glob2regexp (string str)
static mixed	to_filename (string str)
static private void	_parseargs (string str, string *line, int flags, string opts, int build_fn)
static string *	parseargs (string cmdline, int flags, string opts, int build_fn)
private int *	_vc_map (object ob, mixed *list)
private varargs mixed *	_get_files (string dirname, string mask, int mode, string dest)
private mixed *	_get_matching (string *pathmask, int depth, string path, int mode, int recursive, string dest, string filemask)
static varargs mixed *	get_files (string filename, int mode, int recursive, string dest, string filemask)
static varargs mixed *	file_list (string *files, int mode, int recursive, string dest, string mask)

Makro-Dokumentation

#define NEED_PROTOTYPES

Definiert in Zeile 11 der Datei parsing.c.

Dokumentation der Funktionen

private varargs mixed* _get_files	(	string	dirname,
		string	mask,
		int	mode,
		string	dest
	)

Definiert in Zeile 138 der Datei parsing.c.

00139 {
00140   mixed *files,*tmp,*data;
00141   string fullname,base;
00142 
00143   //DEBUG("_GF: DIRNAME " + dirname);
00144   data=get_dir(dirname+"*",7);
00145   if(!sizeof(data)) return ({});
00146   files=({});
00147  
00148   while(sizeof(data))
00149   {
00150     tmp=({});
00151     base=data[BASENAME];
00152     fullname=dirname+base;
00153     if (base!="."&&base!=".."&&(!(mode==MODE_GREP&&base=="RCS"))&&
00154         ((data[FILESIZE]==-2&&
00155        sizeof(tmp=_get_files(fullname+"/",mask,mode,
00156       dest+base+"/"))&&mode!=MODE_RM)||!mask||sizeof(regexp(({ base }),mask))))
00157     {
00158       //DEBUG("_GF: ADDING FILE " + fullname);
00159       files+= ({ data[0..2]+({ fullname,dirname,dest+base,
00160                                sizeof(tmp) }) });
00161     }
00162     if (sizeof(files)+sizeof(tmp)>MAX_ARRAY_SIZE)
00163        raise_error("Zu viele Files (>3000)!! Abgebrochen!\n");
00164     files+=tmp;
00165     data=data[3..];
00166   }
00167   
00168   if(sizeof(files)>300&&!IS_ARCH(this_object()))
00169     // Tod allen Laggern :o)
00170     raise_error("Zu viele Files (>300)!! Abgebrochen!\n");
00171   return files;
00172 }

private mixed* _get_matching	(	string *	pathmask,
		int	depth,
		string	path,
		int	mode,
		int	recursive,
		string	dest,
		string	filemask
	)

Definiert in Zeile 189 der Datei parsing.c.

00192 00193 00194 00195 00196 00197 00198 00199 00200 00201   { 00202 00203     { 00204 00205 00206     } 00207 00208 00209 00210 00211     { 00212 00213 00214 00215     } 00216 00217 00218 00219 00220 00221 00222 00223 00224     { 00225 00226 00227     } 00228 00229 00230 00231 00232   } 00233 00234 00235 00236 00237 }

class="fragment">00191 { mixed *data,*tmp,*files; string base,full; //DEBUG("_GM: PM: " + pathmask[depth]); //DEBUG("_GM: FM: " + filemask); data=get_dir(path+pathmask[depth++],GETDIR_NAMES|GETDIR_SIZES|GETDIR_DATES)||({}); if (!sizeof(data)) return ({}); files=({}); while(sizeof(data)) if ((base=data[BASENAME])=="."||base=="..") data=data[3..]; continue; full=path+base; //DEBUG("_GM: FULL: " + full); if ((data[FILESIZE]==-2)&&(sizeof(pathmask)>depth)&& (!(mode==MODE_GREP&&base=="RCS"))) //DEBUG("DESCEND INTO " + full); tmp=_get_matching(pathmask,depth,full+"/",mode,recursive, (recursive?dest+base+"/":dest),filemask); else tmp=({}); //DEBUG("DEPTH: " + depth + " : " + sizeof(pathmask)); if((!filemask&&(depth==sizeof(pathmask)))|| (filemask&&(depth+2>sizeof(pathmask))&& sizeof(regexp(({ base }),filemask)))|| ((mode==MODE_CP||mode==MODE_MV||(filemask&& (mode==MODE_RM)&&sizeof(regexp(({ base}),filemask))))&& sizeof(tmp))) //DEBUG("ADDING: " + base+ " : "+ full ); files+=({ data[0..2]+({ full, path, dest+base,sizeof(tmp)}) }); if (sizeof(files)+sizeof(tmp)>MAX_ARRAY_SIZE) raise_error("Zu viele Files (>3000)!! Abgebrochen!\n"); files+=tmp; data=data[3..]; if(sizeof(files)>300&&!IS_ARCH(this_object())) // Tod allen Laggern! raise_error("Zu viele Files (>300)!! Abgebrochen!\n"); return files;

static private void _parseargs	(	string	str,
		string *	line,
		int	flags,
		string	opts,
		int	build_fn
	)			`[static]`

Definiert in Zeile 59 der Datei parsing.c.

Benutzt i und to_filename().

00061 {
00062 
00063 // Strings in "" erhalten
00064   if(str[0] == "\""[0])  
00065   { 
00066     line += ({ str[1..<2] });
00067     return; 
00068   }  
00069 //  Flags parsen
00070   if(str[0] == '-')  
00071   { 
00072     int i,j;
00073     i=strlen(str);
00074     while(i--)
00075       if (str[i]!='-')
00076       {
00077         if((j = member(opts, str[i])) != -1)
00078           flags |= (1 << j);
00079         else
00080         {
00081           flags=-1;
00082           printf("Das Flag '-%c' wird von dem Befehl '%s' nicht "
00083                  "unterstuetzt.\n",str[i],query_verb()||"");
00084         }
00085       }
00086     return;
00087   }
00088   if (build_fn)
00089   {
00090     if (str=(string)to_filename(str)) line+=({ str });
00091   } 
00092   else
00093     line+= ({ str });
00094 }

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

private int* _vc_map	(	object	ob,
		mixed *	list
	)

Definiert in Zeile 122 der Datei parsing.c.

00123 {
00124   list+=({ explode(object_name(ob),"/")[<1],-1,program_time(ob) });
00125   return 0;
00126 }

static varargs mixed* file_list	(	string *	files,
		int	mode,
		int	recursive,
		string	dest,
		string	mask
	)			`[static]`

Definiert in Zeile 336 der Datei parsing.c.

Benutzt _unparsed_args(), dtime(), err, get_files(), glob2regexp(), i, list, log_file, result() und SHELLLOG.

Wird benutzt von _cd2(), _clone(), _ed(), _more(), _rmdir() und _upd().

00337 {
00338   string *list,err,*result;
00339   int i,j;
00340   list=({});
00341   if (mask) mask=glob2regexp(mask);
00342   j=sizeof(files);
00343   for(i=0;i<j;i++)
00344   {
00345     if (err=catch(list+=get_files(files[i],mode,recursive,dest,mask)))
00346     {
00347       printf("Fehler aufgetreten: %s\n",err);
00348       log_file(SHELLLOG("FILE_LIST"),
00349                sprintf("%s fuehrte folgendes Kommando aus: (Zeit: %s)\n"
00350                        "  >>%s %s<<\n"
00351                        "  Folgender Fehler trat dabei auf:\n"
00352                        "  %s\n\n",
00353                        capitalize(getuid())||"<Unbekannt>",dtime(time()),
00354                        query_verb()||"*",_unparsed_args()||"*",err||"*"));
00355       return ({});
00356     }
00357   }
00358    return list;
00359 }

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

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

static varargs mixed* get_files	(	string	filename,
		int	mode,
		int	recursive,
		string	dest,
		string	filemask
	)			`[static]`

Definiert in Zeile 251 der Datei parsing.c.

Wird benutzt von file_list().

00252 { 
00253   string full,path,base,*patharray,*vrooms,dest2;
00254   object vcompiler;
00255   mixed *files,*data;
00256 
00257   // DEBUG("GF: " + filename);
00258   // DEBUG("REC: " + recursive + " MODE: " + mode);
00259   // if (dest[<1..<1]!="/") DEBUG("DEST: " + dest);
00260   if (filename=="/")
00261     {
00262       switch (mode)
00263       {
00264         case MODE_LSA: return ({({ "", -2, 0,"","","",0 })});
00265         default: if (!recursive) return ({});
00266                  break;
00267       }
00268     }
00269   patharray=explode(filename,"/");
00270   if(!sizeof(data=get_dir(filename,7)||({}))&&
00271      (mode==MODE_UPD||mode==MODE_MORE||mode==MODE_ED))
00272     data=get_dir(filename+".c",7)||({});
00273   if ((mode==MODE_LSA||mode==MODE_LSB)&&
00274       (vcompiler = find_object(implode(patharray[0..<2],"/")+"/virtual_compiler")) &&
00275       pointerp(vrooms=(mixed *)vcompiler->QueryObjects()))
00276     map(vrooms,#'_vc_map,&data);
00277   files=({});
00278   if (sizeof(data)) // passende files
00279   {
00280     mixed *subfiles;
00281     subfiles=({});
00282     path=implode(patharray[0..<2],"/")+"/";
00283     while (sizeof(data))
00284     {
00285       subfiles=({});
00286       base=data[BASENAME];
00287       if (mode==MODE_LSB||(base!="."&&base!=".."))
00288       {
00289         //DEBUG("PATH: " + path+" BASE: " + base + " MODE: " + mode);
00290         full=path+base;
00291         dest2=((dest=="/"||file_size(dest[0..<2])==-2)?
00292                (dest+base):(dest=="/"?"/":dest[0..<2]));
00293         //DEBUG("DEST: " + dest);
00294         if (recursive&&data[FILESIZE]==-2) // Verzeichnis, Rekursiv
00295           subfiles=_get_files(full+"/",filemask,mode,dest2+"/");
00296         if (!(filemask&&!sizeof(subfiles)&&!sizeof(regexp(({ base }),filemask))))
00297         {
00298           if (!filemask||mode!=MODE_RM)
00299             files+=({ data[0..2]+({ full, path, dest2,sizeof(subfiles)}) });
00300           if (sizeof(files)+sizeof(subfiles)>MAX_ARRAY_SIZE)
00301             raise_error("Zu viele Files (>3000)!! Abgebrochen!\n");
00302           files+=subfiles;
00303         }
00304       }
00305       data=data[3..];
00306     }
00307     return files;
00308   }
00309 // File existiert nicht -> Wildcard oder tatsaechlich nicht existent
00310 // Behandeln je nach mode
00311   switch(mode)
00312   {
00313     case MODE_CP:
00314     case MODE_MV:
00315     case MODE_CD:
00316     case MODE_LSA:
00317       files=_get_matching(patharray+(filemask?({ "*" }):({})),1,"/",mode,
00318                            recursive,dest,filemask);
00319       break;
00320     default: break; 
00321   }
00322   return files;
00323 }

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

static string glob2regexp ( string str ) [static]

Definiert in Zeile 21 der Datei parsing.c.

Wird benutzt von file_list().

00022 {
00023   str=regreplace(str,"([\\.\\^\\$\\[\\]\\(\\)])","\\\\\\1",1);
00024   str=regreplace(str,"\\*",".*",1);
00025   return sprintf("^%s$",regreplace(str,"?",".",1));
00026 }

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

static string* parseargs	(	string	cmdline,
		int	flags,
		string	opts,
		int	build_fn
	)			`[static]`

Definiert in Zeile 107 der Datei parsing.c.

Benutzt i.

Wird benutzt von _cd2(), _clone(), _cp(), _ed(), _man(), _more(), _rman(), _rmdir() und _upd().

00108 {
00109   int i;
00110   string *line;
00111   line=({});
00112   if (!strlen(cmdline)) return ({});
00113   map(regexplode(cmdline,"[\"][^\"]*[\"]| ")-({" ", ""}),
00114             #'_parseargs, &line, &flags,opts, build_fn);
00115   return line - ({""});
00116 }

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

static mixed to_filename ( string str ) [static]

Definiert in Zeile 35 der Datei parsing.c.

Benutzt i, master, p, P_VARIABLES und QueryProp().

Wird benutzt von _cp() und _parseargs().

00036 {
00037   string *tmp,p,newfn;
00038   int i;
00039 // Testen ob .. in einem Filenamenabschnitt, falls Version <3.2.5
00040   tmp=explode(str,"/");
00041 // Testen auf Pfadvariable
00042   if (strlen(tmp[0]) && tmp[0][0]=='$' 
00043       && m_contains(&p,QueryProp(P_VARIABLES),tmp[0][1..]))
00044     tmp[0]=p;
00045 // Pfad absolut machen (Hat danach noch Wildcards drinnen) oder auch nicht
00046   return master()->make_path_absolute(implode(tmp,"/"));
00047 }

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

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

parsing.c-Dateireferenz

Makrodefinitionen

Funktionen

Makro-Dokumentation

Dokumentation der Funktionen