| // MorgenGrauen MUDlib |
| // |
| // fileview.c |
| // |
| // $Id: fileview.c 9142 2015-02-04 22:17:29Z Zesstra $ |
| #pragma strict_types |
| #pragma save_types |
| //#pragma range_check |
| #pragma no_clone |
| #pragma pedantic |
| |
| #include <ansi.h> |
| #include <player/base.h> |
| #include <wizlevels.h> |
| #include <shells.h> |
| #include <daemon/mand.h> |
| #include <udp.h> |
| #define NEED_PROTOTYPES |
| #include <magier.h> |
| #include <thing/properties.h> |
| #include <player.h> |
| |
| private nosave mapping colorstrings; |
| private nosave mapping oldman_result; |
| |
| // ################### |
| //######################### INITIALISIERUNG ############################# |
| // ################### |
| |
| mixed _query_localcmds() |
| { |
| return ({({"ls","_ls",0,LEARNER_LVL}), |
| ({"more","_more",0,LEARNER_LVL}), |
| ({"cat","_cat",0,LEARNER_LVL}), |
| ({"head","_cat",0,LEARNER_LVL}), |
| ({"tail","_cat",0,LEARNER_LVL}), |
| ({"man","_man",0,LEARNER_LVL}), |
| ({"rman","_rman",0,LEARNER_LVL}), |
| ({"showprops","_showprops",0,WIZARD_LVL}), |
| ({"grep","_grep",0,LEARNER_LVL})}); |
| } |
| |
| |
| // ###### |
| //################################ LS ################################### |
| // ###### |
| |
| // |
| // _ls: Der ls-Befehl: Verzeichnisse und Dateien anzeigen |
| // cmdline: Kommandozeile |
| // |
| |
| // |
| // Funktionen zum Sortieren und fuer filter_ldfied/map_ldfied |
| // |
| |
| |
| private string _get_color(string color) |
| { |
| return COLORS[lower_case(color)]; |
| } |
| |
| |
| private void SetColorstrings() |
| { |
| string tmp,term; |
| mapping vars; |
| vars=QueryProp(P_VARIABLES); |
| colorstrings=m_allocate(0,2); |
| switch(term=QueryProp(P_TTY)) |
| { |
| case "vt100": |
| case "ansi": |
| if(stringp(vars["LS_DIR"])) |
| tmp=implode(map(explode(vars["LS_DIR"],"+"),#'_get_color), |
| ""); |
| else |
| tmp = (term == "ansi") ? ANSI_BLUE+ANSI_BOLD: ANSI_BOLD; |
| colorstrings[DIR] = tmp+"%s"+(term == "vt100"?"/":"")+ANSI_NORMAL; |
| if(term == "vt100") colorstrings[DIR, 1] = 1; |
| if(stringp(vars["LS_OBJ"])) |
| tmp=implode(map(explode(vars["LS_OBJ"],"+"),#'_get_color), |
| ""); |
| else |
| tmp = (term == "ansi") ? ANSI_RED : ANSI_INVERS; |
| colorstrings[OBJ] = tmp+"%s"+ANSI_NORMAL; |
| if(stringp(vars["LS_VC"])) |
| tmp=implode(map(explode(vars["LS_VC"],"+"),#'_get_color), |
| ""); |
| else |
| tmp = (term == "ansi") ? ANSI_PURPLE : ANSI_INVERS; |
| colorstrings[VC] = tmp+"%s"+ANSI_NORMAL; |
| break; |
| case "dumb": |
| colorstrings[DIR] = "%s/"; colorstrings[DIR, 1] = 1; |
| colorstrings[OBJ] = "%s*"; colorstrings[OBJ, 1] = 1; |
| colorstrings[VC] = "%s*"; colorstrings[VC , 1] = 1; |
| break; |
| default: |
| colorstrings[DIR] = "%s"; |
| colorstrings[OBJ] = "%s"; |
| colorstrings[VC] = "%s"; |
| } |
| return; |
| } |
| |
| |
| private string _ls_output_short(mixed filedata, |
| int maxlen,int counter,int maxcount) |
| { |
| string tmp; |
| tmp=filedata[BASENAME]; |
| maxlen-=sizeof(tmp); |
| switch(filedata[FILESIZE]) |
| { |
| case -2: tmp=sprintf(colorstrings[DIR],tmp); |
| maxlen-=colorstrings[DIR,1]; break; |
| case -1: tmp=sprintf(colorstrings[VC],tmp); |
| maxlen-=colorstrings[VC,1]; break; |
| default: if (find_object(filedata[FULLNAME])) |
| { |
| maxlen-=colorstrings[OBJ,1]; |
| tmp=sprintf(colorstrings[OBJ],tmp); break; |
| } |
| } |
| if (!maxcount) return tmp+"\n"; |
| return sprintf("%-*s%s",(maxlen+sizeof(tmp)),tmp, |
| ((counter++)==maxcount?(counter=0,"\n"):" ")); |
| } |
| |
| private int _ls_maxlen(mixed filedata,int flags,int maxlen) |
| { |
| string base; |
| int size; |
| base=filedata[BASENAME]; |
| if (!(flags&LS_A)&&(base[0]=='.')) return 0; |
| #if __VERSION__ < "3.2.9" |
| if (sizeof(base)>maxlen) maxlen=sizeof(base); |
| #else |
| maxlen=max(maxlen,sizeof(base)); |
| #endif |
| return 1; |
| } |
| |
| private string _ls_output_long(mixed filedata, int flags,closure valid_read, |
| closure valid_write,closure creator_file) |
| { |
| string *tmp,full,base,path,date,creator,group; |
| int size,dir,ftime; |
| object ob; |
| |
| base=filedata[BASENAME]; |
| if (!(sizeof(base))||((!(flags&LS_A))&&(base[0]=='.'))) |
| return 0; |
| size=filedata[FILESIZE]; |
| path=filedata[PATHNAME]; |
| tmp=(string *)call_other(master(),"full_path_array", |
| filedata[FULLNAME],getuid()); |
| full=sprintf("/%s",implode(tmp,"/")); |
| dir=(size==-2); |
| ob=find_object(full); |
| ftime=filedata[FILEDATE]; |
| date=dtime(ftime); |
| date=sprintf("%s %s %s",date[9..11],date[5..6], |
| ((time()-ftime)<31536000?date[19..23]:(" "+date[13..16]))); |
| creator=""; |
| group=""; |
| if (flags&LS_U) |
| { |
| creator=(string)call_other(master(),"creator_file",full); |
| switch(creator) |
| { |
| case ROOTID: creator="root"; break; |
| case BACKBONEID: creator="daemon"; break; |
| default: if(!creator) creator="none"; break; |
| } |
| } |
| if (flags&LS_G) |
| { |
| if (sizeof(tmp)) |
| { |
| switch(tmp[0]) |
| { |
| case WIZARDDIR: group="magier"; break; |
| case "news": group="news"; break; |
| case "mail": group="mail"; break; |
| case "open": group="public"; break; |
| case "p": group="project"; break; |
| case DOMAINDIR: if (sizeof(tmp)>1) { group=tmp[1]; break; } |
| default: group="mud"; break; |
| } |
| } |
| else group="mud"; |
| } |
| if (dir) base=sprintf(colorstrings[DIR],base); |
| else |
| { |
| if (ob) |
| { |
| if (size==-1) |
| base=sprintf(colorstrings[VC],base); |
| else |
| base=sprintf(colorstrings[OBJ],base); |
| } |
| } |
| return sprintf(("%c%c%c%c %3d"+((flags&LS_U)?" %-24.24s":"%-0.1s")+ |
| ((flags&LS_G)?" %-8.8s":"%0.1s")+" %8s %s %s\n"), |
| (dir?'d':'-'), |
| (!funcall(valid_read,full,getuid(), |
| "read_file",this_object())?'-':'r'), |
| (!funcall(valid_write,full,getuid(), |
| "write_file",this_object())?'-':'w'), |
| (ob?'x':'-'), |
| (dir?(sizeof((get_dir(full+"/*")||({}))-({".",".."}))):0), |
| creator,group,(dir?"-":size==-1?"<vc>":to_string(size)), |
| date,base); |
| } |
| |
| |
| static int _ls(string cmdline) |
| { |
| int flags,cmp,i,arg_size,size; |
| int maxlen,counter,maxcount; |
| string *args,output; |
| mixed *tmp; |
| closure output_fun,v_read,v_write,creator,sort_fun; |
| |
| cmdline=_unparsed_args()||""; |
| args=parseargs(cmdline,&flags,LS_OPTS,1); |
| if (flags==-1) |
| return USAGE("ls [-" LS_OPTS "] [<Verzeichnis>] [<Verzeichnis2> ..]"); |
| SetColorstrings(); |
| output=""; |
| if (!sizeof(args)) args=({ QueryProp(P_CURRENTDIR) }); |
| if (!sizeof(args=file_list(args,MODE_LSA,0,"/"))) |
| return notify_fail("ls: Keine passenden Verzeichnisse gefunden.\n"), 0; |
| // Files sortieren die erste |
| if (flags&LS_T) cmp=FILEDATE; |
| else if (flags&LS_S) cmp=FILESIZE; |
| else cmp=BASENAME; // =0 :-) |
| sort_fun=lambda(({ 'a,'b }),({ |
| ((!cmp&&!(flags&LS_R))||(cmp&&(flags&LS_R))?#'>:#'<), |
| ({#'[,'a,cmp}),({#'[,'b,cmp})})); |
| args=sort_array(args,sort_fun); |
| // Ausgabeformat bestimmen |
| if (flags&LS_L) |
| { |
| v_read=VALID_READ_CL; |
| v_write=VALID_WRITE_CL; |
| creator=CREATOR_CL; |
| } |
| arg_size=sizeof(args); |
| if (arg_size>1||(arg_size&&args[0][FILESIZE]>=0)) |
| { |
| if (flags&LS_L) |
| tmp=map(args,#'_ls_output_long,flags,v_read, |
| v_write,creator)-({0}); |
| else |
| { |
| counter=0;maxlen=0; |
| tmp=filter(args,#'_ls_maxlen,flags,&maxlen); |
| if (maxlen>76) maxlen=76; |
| maxcount=(78/(maxlen+2))-1; |
| tmp=map(tmp,#'_ls_output_short,maxlen,&counter,maxcount); |
| } |
| output=sprintf("\n%d Dateien/Unterverzeichnisse:\n%s\n", |
| sizeof(tmp),implode(tmp,"")); |
| } |
| for(i=0;i<arg_size;i++) |
| { |
| tmp=({}); |
| size=args[i][FILESIZE]; |
| if (size==-2) |
| { |
| tmp=file_list(({args[i][FULLNAME]+"/*"}),MODE_LSB,0,"/"); |
| tmp=sort_array(tmp,sort_fun); |
| if (flags&LS_L) |
| tmp=map(tmp,#'_ls_output_long,flags,v_read, |
| v_write,creator)-({0}); |
| else |
| { |
| counter=0;maxlen=0; |
| tmp=filter(tmp,#'_ls_maxlen,flags,&maxlen); |
| maxcount=(78/(maxlen+2)); |
| if (maxcount) maxcount--; |
| tmp=map(tmp,#'_ls_output_short,maxlen,&counter,maxcount); |
| } |
| if (sizeof(tmp)) |
| { |
| output+=sprintf("\n%s: Verzeichnis, %d Dateien/Unterverzeichnisse:\n", |
| args[i][FULLNAME],sizeof(tmp)); |
| output+=(implode(tmp,"")+((string)(tmp[<1][<1..<1])=="\n"?"":"\n")); |
| } |
| else |
| { |
| output+=sprintf("\n%s: Leeres Verzeichnis.\n",args[i][FULLNAME]); |
| } |
| } |
| } |
| More(output); |
| return 1; |
| } |
| |
| // ######## |
| //############################### MORE ################################### |
| // ######## |
| // |
| // _more_file: Mehrere Files hintereinander ausgeben |
| // |
| |
| private void _more_file(string *arg) |
| { |
| if (!sizeof(arg)) return; |
| printf("more: Naechste Datei: %s\n",arg[0]); |
| More(arg[0],1,#'_more_file,({ arg[1..]})); |
| return; |
| } |
| |
| |
| private mixed _size_filter(mixed *arg) |
| { |
| if (arg[FILESIZE]>0) return arg[FULLNAME]; |
| if (arg[FILESIZE]==0) |
| { |
| printf("%s: %s: Leere Datei.\n",query_verb()||"more",arg[FULLNAME]); |
| return 0; |
| } |
| if (arg[FILESIZE]==-2) |
| printf("%s: %s ist ein Verzeichnis.\n",query_verb()||"more",arg[FULLNAME]); |
| else |
| printf("%s: %s: Datei existiert nicht.\n", query_verb()||"more", |
| arg[FULLNAME]); |
| return 0; |
| } |
| |
| |
| // |
| // _more: Dateien anzeigen |
| // cmdline: Kommandozeile |
| // |
| |
| static int _more(string cmdline) |
| { |
| mixed *args; |
| int flags; |
| cmdline=_unparsed_args(); |
| args=parseargs(cmdline,&flags,"",1); |
| if (flags==-1||!sizeof(args)) return USAGE("more <datei> [<datei2>..]"); |
| args=file_list(args,MODE_MORE,0,"/"); |
| if (!sizeof(args)) |
| return printf("more: %s: Keine passende Datei gefunden.\n",cmdline),1; |
| args=map(args,#'_size_filter)-({0}); |
| if (sizeof(args)) _more_file(args); |
| return 1; |
| } |
| |
| // ################### |
| //########################## HEAD, TAIL, CAT ############################# |
| // ################### |
| |
| static int _cat(string cmdline) |
| { |
| mixed *args; |
| int flags; |
| cmdline=_unparsed_args(); |
| args=parseargs(cmdline,&flags,"",1); |
| if(flags==-1||!sizeof(args)) |
| return USAGE(query_verb()+" <dateiname> [<datei2>..]"); |
| args=file_list(args,MODE_CAT,0,"/"); |
| if (!sizeof(args)) |
| return printf("%s: %s: Keine passende Datei gefunden.\n",query_verb(), |
| cmdline),1; |
| args=map(args,#'_size_filter)-({0}); |
| if (!sizeof(args)) return 1; |
| while(sizeof(args)) |
| { |
| switch(query_verb()) |
| { |
| case "cat": |
| if (!cat(args[0])) |
| printf("cat: %s konnte nicht angezeigt werden.\n",args[0]); |
| break; |
| case "head": |
| if (!cat(args[0],0,10)) |
| printf("head: %s konnte nicht angezeigt werden.\n",args[0]); |
| break; |
| case "tail": tail(args[0]); break; |
| } |
| args=args[1..]; |
| } |
| return 1; |
| } |
| |
| // ####### |
| //############################### MAN ################################### |
| // ####### |
| |
| static int _man(string cmdline) |
| { |
| mixed *args; |
| int i, flags; |
| string *tmp, *tmp2; |
| |
| cmdline=_unparsed_args(); |
| args=parseargs(cmdline,&flags,MAN_OPTS,0); |
| |
| if (flags==-1 || |
| (sizeof(args)!=1 && |
| (sizeof(args)<2 || sizeof(args[1])>1 || !(i=to_int(args[1]))))) |
| return USAGE("man [-" MAN_OPTS "] <hilfeseite>"); |
| tmp=explode(args[0],"/"); |
| |
| if (oldman_result && sizeof(tmp)==1 && sizeof(args)==1 && |
| sizeof(tmp[0])==1 && (i=to_int(tmp[0])) && member(oldman_result,i)) { |
| tmp=({oldman_result[i,0],oldman_result[i,1]}); |
| i=0; |
| } |
| else if (!(flags&(MAN_M|MAN_R))&&sizeof(tmp)>1) |
| { |
| if (file_size(MAND_DOCDIR+args[0])>=0) |
| tmp=({tmp[<1],args[0]}); |
| else |
| tmp=({}); |
| } |
| else |
| { |
| if (flags&MAN_R) |
| { |
| flags&=(~MAN_M); |
| if (catch(regexp(({""}),args[0]))|| |
| !regexp(({""}),args[0])) |
| return printf("man: Ungueltiger Ausdruck in Maske.\n"),1; |
| } |
| tmp=(string *)call_other(MAND,"locate",args[0],flags&(MAN_M|MAN_R)); |
| } |
| |
| oldman_result=(mapping)0; |
| if(i && sizeof(tmp)>2 && sizeof(tmp)>=(i<<1)) |
| tmp=tmp[((i<<1)-2)..((i<<1)-1)]; |
| switch(sizeof(tmp)) |
| { |
| case 0: |
| printf("Keine Hilfeseite gefunden fuer '%s'.\n",args[0]); |
| break; |
| case 2: |
| /* |
| if (flags&MAN_I) |
| { |
| // BRANCH TO MANUALD |
| return 1; |
| } |
| */ |
| printf("Folgende Hilfeseite wurde gefunden: %s\n",tmp[1]); |
| More(MAND_DOCDIR+tmp[1],1); |
| return 1; |
| default: |
| i=sizeof(tmp)>>1; |
| tmp2=allocate(i); |
| oldman_result=m_allocate(i,2); |
| while(i) |
| { |
| tmp2[(i-1)]=sprintf("%d: ",i)+tmp[(i<<1)-2]; |
| oldman_result[i,0]=tmp[(i<<1)-2]; |
| oldman_result[i,1]=tmp[(i<<1)-1]; |
| i--; |
| } |
| printf("Es wurden folgende potentiell passenden Seiten gefunden:\n" |
| "%'-'78.78s\n%s%'-'78.78s\n","", |
| break_string(implode(tmp2," "),78),""); |
| break; |
| } |
| return 1; |
| } |
| |
| // ######## |
| //############################### RMAN ################################## |
| // ######## |
| |
| static int _rman(string str) |
| { |
| int flags; |
| string *args; |
| |
| str=_unparsed_args(); |
| args=parseargs(str,&flags,"",0); |
| if (flags==-1||sizeof(args)!=2) |
| return USAGE("rman <hilfeseite> <mudname>"); |
| write("man: " + |
| (string)call_other(UDP_CMD_DIR+"man","send_request",args[1],args[0])); |
| return 1; |
| } |
| |
| |
| // ############# |
| //############################# SHOWPROPS ############################### |
| // ############# |
| |
| // |
| // _showprops: Zeigt Properties zu einem Objekt an |
| // |
| |
| static int _showprops(string str) |
| { |
| int i; |
| string *list, ausgabe; |
| |
| if (str) { |
| if (str[0]!='/') str="/"+str; |
| if (str[0..4]!="/std/") |
| { |
| printf("showprops: Es koennen nur Properties von Objekten " |
| "aus /std/ angezeigt werden.\n"); |
| return 1; |
| } |
| if (str[<1]=='.') str+="c"; |
| if (str[<2..<1]!=".c") str+=".c"; |
| if (file_size(str)<0) |
| { |
| printf("showprops: %s: Es gibt kein Objekt diesen Namens.\n",str[0..<3]); |
| return 1; |
| } |
| if (catch(call_other(str[0..<3], "???"))) |
| { |
| printf("showprops: %s: Datei konnte nicht geladen werden.\n",str); |
| return 1; |
| } |
| } |
| if (!str || !find_object(str)) { |
| notify_fail("Welche Properties moechtest Du sehen?" |
| " Bsp.: <showprops /std/npc>\n"); |
| return 0; |
| } |
| list=inherit_list(find_object(str)); |
| #if __VERSION__ < "3.2.9" |
| list=map(list,lambda(({'x}),({#'extract,'x,4,-2}))); |
| list+=map(list,lambda(({'x}),({#'[<,({#'old_explode,'x,"/"}),1}))); |
| list=map(m_indices(mkmapping(list)),lambda(({'x}),({#'+,({#'+,"/sys/",'x}),"h"}))); |
| list=filter(list,lambda(({'x}),({#'>,({#'file_size,'x}),0})) ); |
| #else |
| list=map(list,(: return $1[5..<2]+"h"; :)); |
| list+=map(list,(: return explode($1,"/")[<1]; :)); |
| list=map(m_indices(mkmapping(list)),(: return "/sys/"+$1; :)); |
| list=filter(list,(: return file_size($1)>0; :)); |
| #endif |
| list=sort_array(list, #'<); |
| ausgabe=""; |
| for (i=sizeof(list);i--;) |
| { |
| #if __VERSION__ < "3.2.9" |
| str=implode(filter(old_explode(read_file(list[i]), "\n"), |
| lambda( ({ 'x }), ({#'==, ({#'extract, 'x, 0, 9}), "#define P_"}) )) |
| , "\n"); |
| #else |
| str=implode(filter(explode(read_file(list[i]),"\n"), |
| (: return $1[0..9]=="#define P_";:)),"\n"); |
| #endif |
| if (str!="") ausgabe+=sprintf("%s\n%s\n\n", list[i], str); |
| } |
| if (ausgabe!="") |
| More(ausgabe); |
| else |
| printf("Keine Property-Definitionen zu diesem Objekt gefunden!\n"); |
| return 1; |
| } |
| |
| // ######## |
| //############################### GREP ################################### |
| // ######## |
| |
| #if __VERSION__ < "3.2.9" |
| |
| private int _grep_filter(string filename) |
| { |
| return (call_other("valid_write",filename,getuid(this_object()), |
| "write_file",this_object())!=0); |
| } |
| |
| #endif |
| |
| // |
| // grep_file: Datei greppen |
| // rexpr: Regular Expression |
| // flags: Flags |
| // |
| |
| private int grep_file(mixed filedata, string rexpr, int flags) |
| { |
| string fullname,data,carry,*lines,*lines_orig,*tmp,*result; |
| int ptr,count,i,nol,match,index; |
| fullname=filedata[FULLNAME]; |
| if ((flags&GREP_F)&&fullname=="/players/"+getuid()+"/grep.out") |
| { |
| write_file("/players/"+getuid()+"/grep.out", |
| "Uebergehe grep.out ...\n"); |
| return RET_FAIL; |
| } |
| switch(filedata[FILESIZE]) |
| { |
| case -2: return RET_FAIL; |
| case -1: return ERROR(DOESNT_EXIST,fullname,RET_FAIL); |
| case 0: return RET_FAIL; |
| default: break; |
| } |
| if (!MAY_READ(fullname)) return ERROR(NO_READ,fullname,RET_FAIL); |
| carry=""; result=({}); |
| if (flags&GREP_I) |
| rexpr=lower_case(rexpr); |
| do |
| { |
| data=read_bytes(fullname,ptr,MAXLEN)||""; |
| ptr+=MAXLEN; |
| lines=explode(carry+data,"\n"); |
| switch(sizeof(lines)) |
| { |
| case 0: continue; |
| case 1: |
| carry=""; |
| break; |
| default: |
| carry=lines[<1]; |
| lines=lines[0..<2]; |
| break; |
| } |
| lines_orig=lines; |
| if (flags&GREP_I) |
| lines=map(lines,#'lower_case); |
| nol=sizeof(lines); |
| for (i=0;i<nol;i++) |
| { |
| match=sizeof(regexp(lines[i..i],rexpr)); |
| if (flags&GREP_V) match=!match; |
| if (match) |
| { |
| if (!(flags&GREP_C)) |
| { |
| if (flags&GREP_N) |
| result+=({ sprintf("%4d %s",index+i+1,lines_orig[i])}); |
| else |
| result+=lines_orig[i..i]; |
| } |
| count++; |
| } |
| } |
| index+=nol; |
| } |
| while(sizeof(data)==MAXLEN); |
| if (carry!="") |
| { |
| if (flags&GREP_I) carry=lower_case(carry); |
| match=sizeof(regexp(({ carry }),rexpr)); |
| if (flags&GREP_V) match=!match; |
| if (match) |
| { |
| if(!(flags&GREP_C)) |
| { |
| if(flags&GREP_N) |
| result+=({ sprintf("%4d %s",index+1,carry) }); |
| else |
| result+=({carry}); |
| } |
| count++; |
| } |
| } |
| carry=""; |
| if (count) |
| { |
| if (flags&GREP_L) carry=sprintf("%s\n",fullname); |
| else if (flags&GREP_H) data=""; |
| else data=sprintf(" %s:",fullname); |
| if (flags&GREP_C) carry=sprintf("%s %d passende Zeile%s.\n",data,count, |
| (count==1?"":"n")); |
| else |
| carry=(data+"\n"+implode(result,"\n")+"\n"); |
| } |
| if (flags&GREP_F) |
| return write_file("/players/"+getuid()+"/grep.out",carry); |
| write(carry); |
| return RET_OK; |
| } |
| |
| static int _grep(string cmdline) |
| { |
| string rexpr,mask; |
| mixed *args; |
| int flags; |
| cmdline=_unparsed_args(); |
| args=parseargs(cmdline,&flags,GREP_OPTS,0); |
| if ((flags==-1)||!sizeof(args)) |
| return USAGE("grep [-" GREP_OPTS |
| "] <regexp> <datei/verz> [<datei2> ... ] [<maske>]"); |
| rexpr=args[0]; |
| if (catch(regexp(({""}),rexpr))||!regexp(({""}),rexpr)) |
| return printf("grep: Ungueltiger Suchausdruck: %s\n",rexpr) ,1; |
| args=args[1..]; |
| if (flags&GREP_M) |
| { |
| mask=args[<1]; |
| args=args[0..<2]; |
| } |
| if (!sizeof(args)) |
| return USAGE("grep [-" GREP_OPTS |
| "] <regexp> <datei/verz> [<datei2> ... ] [<maske>]"); |
| args=map(args,#'to_filename)-({0}); |
| /* |
| #if __VERSION__ < "3.2.9" |
| args=filter(args,#'_grep_filter); |
| #else |
| args=filter(args,(: return (valid_write($1, |
| getuid(this_object()),"write_file",this_object())!=0):)); |
| #endif |
| */ |
| args=file_list(args,MODE_GREP,(flags&GREP_R?1:0),"/",mask); |
| if (!sizeof(args)) |
| return printf("Keine passenden Dateien gefunden.\n"),1; |
| if (flags&GREP_I) rexpr=lower_case(rexpr); |
| if (flags&GREP_F) |
| { |
| if (file_size("/players/"+getuid()+"/grep.out")==-2|| |
| !MAY_WRITE("/players/"+getuid()+"/grep.out")) |
| return printf("grep: Datei /players/%s/grep.out kann nicht " |
| "geschrieben werden.\n",getuid()),1; |
| else |
| write_file("/players/"+getuid()+"/grep.out", |
| "Ausgabe von \"grep " + _unparsed_args() + "\":\n"); |
| } |
| asynchron(args,#'grep_file,rexpr,flags,0); |
| return 1; |
| } |