| // MorgenGrauen MUDlib |
| // |
| // fileview.c |
| // |
| // $Id: fileview.c 9142 2015-02-04 22:17:29Z Zesstra $ |
| #pragma strict_types, rtt_checks |
| #pragma range_check |
| #pragma no_clone |
| |
| #include <ansi.h> |
| #include <player/base.h> |
| #include <wizlevels.h> |
| #include <shells.h> |
| #include <daemon/mand.h> |
| #include <udp.h> |
| #include <files.h> |
| #include <rtlimits.h> |
| |
| #define NEED_PROTOTYPES |
| #include <magier.h> |
| #include <thing/properties.h> |
| #include <player.h> |
| |
| struct lsformats { |
| mapping templates; |
| mapping colormap; |
| }; |
| private nosave struct lsformats lstemplates; |
| 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 |
| // |
| |
| // Helfer fuer map() zum extrahieren benutzerdefinierte Farben aus P_VARIABLES |
| private string _get_color(string color) |
| { |
| return COLORS[lower_case(color)]; |
| } |
| |
| // Ermittelt Farbtags und Formattemplates mit Platzhaltern fuer ls-Ausgaben |
| // und bereitet beides fuer die Nutzung durch terminal_colours() vor. |
| private void SetColorstrings() |
| { |
| mapping vars = QueryProp(P_VARIABLES); |
| // 2nd value in templates is the additional amount of space the templates |
| // itself needs in addition to the value inserted later in place of %s. |
| lstemplates = (<lsformats> templates: m_allocate(3,2), |
| colormap:m_allocate(4,1) ); |
| // 0-Key ist der default, wenn ein Platzhalter nicht gefunden wird. Wird |
| // z.B. fuer Ende-Tags benutzt. |
| lstemplates.colormap[0]=ANSI_NORMAL; |
| // Template fuer die Ausgabe und die Defaults fuer die Farbplatzhalter je |
| // nach Terminal einstellen. |
| switch(QueryProp(P_TTY)) |
| { |
| case "vt100": |
| lstemplates.templates[DIR] = "%^LS_DIR_START%^%s/%^LS_DIR_END%^"; |
| lstemplates.templates[DIR, 1] = 1; |
| lstemplates.templates[OBJ] = "%^LS_OBJ_START%^%s%^LS_OBJ_END%^"; |
| lstemplates.templates[VC] = "%^LS_VC_START%^%s%^LS_VC_END%^"; |
| lstemplates.colormap["LS_DIR_START"]=ANSI_BOLD; |
| lstemplates.colormap["LS_OBJ_START"]=ANSI_INVERS; |
| lstemplates.colormap["LS_VC_START"]=ANSI_INVERS; |
| // Die *_END Platzhalter sind nicht explizit aufgefuehrt, solange sie |
| // nur ANSI_NORMAL normal waeren - in dem Fall benutzt terminal_colour() |
| // spaeter den 0-Key in colormap |
| break; |
| case "ansi": |
| lstemplates.templates[DIR] = "%^LS_DIR_START%^%s%^LS_DIR_END%^"; |
| lstemplates.templates[OBJ] = "%^LS_OBJ_START%^%s%^LS_OBJ_END%^"; |
| lstemplates.templates[VC] = "%^LS_VC_START%^%s%^LS_VC_END%^"; |
| lstemplates.colormap["LS_DIR_START"]=ANSI_BLUE+ANSI_BOLD; |
| lstemplates.colormap["LS_OBJ_START"]=ANSI_RED; |
| lstemplates.colormap["LS_VC_START"]=ANSI_PURPLE; |
| // Die *_END Platzhalter sind nicht explizit aufgefuehrt, solange sie |
| // nur ANSI_NORMAL normal waeren - in dem Fall benutzt terminal_colour() |
| // spaeter den 0-Key in colormap |
| break; |
| // In diesen Faellen keine Farbcodeplatzhalter, nur zeichenbasierte |
| // Markierungen anhaengen. |
| case "dumb": |
| default: |
| m_add(lstemplates.templates, DIR, "%s/", 1); |
| m_add(lstemplates.templates, OBJ, "%s*", 1); |
| m_add(lstemplates.templates, VC, "%s*", 1); |
| break; |
| } |
| // Die Defaults von oben koennen mit magierindividuellen Einstellungen |
| // ueberschrieben werden. Offensichtlich sind die nur wirksam fuer |
| // vt100/ansi und man koennte auch ANSI-Sequenzen einstellen, die ein vt100 |
| // nicht versteht... |
| if(stringp(vars["LS_DIR"])) |
| lstemplates.colormap["LS_DIR_START"]=implode(map( |
| explode(vars["LS_DIR"],"+"), #'_get_color),""); |
| if(stringp(vars["LS_OBJ"])) |
| lstemplates.colormap["LS_OBJ_START"]=implode(map( |
| explode(vars["LS_OBJ"],"+"), #'_get_color),""); |
| if(stringp(vars["LS_VC"])) |
| lstemplates.colormap["LS_VC_START"]=implode(map( |
| explode(vars["LS_VC"],"+"), #'_get_color),""); |
| } |
| |
| |
| private string _ls_output_short(<int|string>* filedata, int maxlen, |
| int counter, int maxcount) |
| { |
| string filename = filedata[BASENAME]; |
| maxlen -= sizeof(filename); |
| switch(filedata[FILESIZE]) |
| { |
| case FSIZE_DIR: |
| filename = sprintf(lstemplates.templates[DIR], filename); |
| maxlen -= lstemplates.templates[DIR, 1]; |
| break; |
| case FSIZE_NOFILE: |
| filename = sprintf(lstemplates.templates[VC], filename); |
| maxlen -= lstemplates.templates[VC, 1]; |
| break; |
| default: |
| if(find_object(filedata[FULLNAME])) |
| { |
| maxlen -= lstemplates.templates[OBJ, 1]; |
| filename = sprintf(lstemplates.templates[OBJ], filename); |
| break; |
| } |
| } |
| if(!maxcount) |
| return terminal_colour(filename + "\n", lstemplates.colormap); |
| return terminal_colour( |
| sprintf( |
| "%-*s%s", |
| (maxlen + sizeof(filename)), |
| filename, |
| ((counter++) == maxcount ? (counter = 0, "\n") : " ")), |
| lstemplates.colormap); |
| } |
| |
| private int _ls_maxlen(<int|string>* filedata,int flags, int maxlen) |
| { |
| string base = filedata[BASENAME]; |
| if(!(flags & LS_A) && base[0] == '.') return 0; |
| maxlen = max(maxlen, sizeof(base)); |
| return 1; |
| } |
| |
| private string _ls_output_long(mixed filedata, int flags,closure valid_read, |
| closure valid_write,closure creator_file) |
| { |
| string base=filedata[BASENAME]; |
| if (!(sizeof(base)) || ( (!(flags&LS_A)) && (base[0]=='.')) ) |
| return 0; |
| int size=filedata[FILESIZE]; |
| string path=filedata[PATHNAME]; |
| string full=filedata[FULLNAME]; |
| int dir=(size==FSIZE_DIR); |
| object ob=find_object(full); |
| int ftime=filedata[FILEDATE]; |
| string date; |
| if ((time()-ftime)>31536000) // ein Jahr |
| date=strftime("%b %e %Y", ftime); |
| else |
| date=strftime("%b %e %H:%M", ftime); |
| |
| string creator=""; |
| string group=""; |
| if (flags&LS_U) |
| { |
| creator=({string})call_other(master(),"creator_file", full); |
| switch(creator) |
| { |
| case ROOTID: creator="root"; break; |
| case BACKBONEID: creator="std"; break; |
| case MAILID: creator="mail"; break; |
| case NEWSID: creator="news"; break; |
| case NOBODY: creator="nobody"; break; |
| case POLIZEIID: creator="polizei"; break; |
| case DOCID: creator="doc"; break; |
| case GUILDID: creator="gilde"; break; |
| case ITEMID: creator="items"; break; |
| default: if(!creator) creator="none"; break; |
| } |
| } |
| if (flags&LS_G) |
| { |
| string *tmp=explode(path, "/") - ({""}); |
| if (sizeof(tmp)) |
| { |
| switch(tmp[0]) |
| { |
| case WIZARDDIR: group="magier"; break; |
| case NEWSDIR: group="news"; break; |
| case MAILDIR: group="mail"; break; |
| case FTPDIR: group="public"; break; |
| case PROJECTDIR: group="project"; break; |
| case DOMAINDIR: if (sizeof(tmp)>1) { group=tmp[1]; break; } |
| default: group="mud"; break; |
| } |
| } |
| else group="mud"; |
| } |
| if (dir) base=sprintf(lstemplates.templates[DIR],base); |
| else |
| { |
| if (ob) |
| { |
| if (size==FSIZE_NOFILE) |
| base=sprintf(lstemplates.templates[VC],base); |
| else |
| base=sprintf(lstemplates.templates[OBJ],base); |
| } |
| } |
| return terminal_colour( |
| 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==FSIZE_NOFILE ? "<vc>" : to_string(size)), |
| date, base), |
| lstemplates.colormap); |
| } |
| |
| private string* _ls_list(< <int|string>* >* targets, int flags, closure v_read, |
| closure v_write, closure creator) |
| { |
| string* entries; |
| if (flags&LS_L) |
| { |
| entries = map(targets, #'_ls_output_long, flags, v_read, |
| v_write, creator) - ({0}); |
| } |
| else |
| { |
| int counter, maxlen; |
| targets = filter(targets, #'_ls_maxlen, flags, &maxlen); |
| if (maxlen > 76) maxlen = 76; |
| // maxcount muss immer um 1 niedriger sein als die tatsaechliche Anzahl an |
| // moeglichen Spalten, weil gegen maxcount++ und nicht gegen ++maxcount |
| // geprueft wird. |
| int maxcount = (78 / (maxlen + 2)) - 1; |
| entries = map(targets, #'_ls_output_short, maxlen, &counter, maxcount); |
| } |
| return entries; |
| } |
| |
| |
| static int _ls(string cmdline) |
| { |
| int flags; |
| |
| string* args = parseargs(_unparsed_args() || "", &flags, LS_OPTS, 1); |
| if(flags == -1) |
| return USAGE("ls [-" LS_OPTS "] [<Verzeichnis>] [<Verzeichnis2> ..]"); |
| SetColorstrings(); |
| if(!sizeof(args)) |
| args = ({ QueryProp(P_CURRENTDIR) }); |
| < <int|string>* >* targets = file_list(args,MODE_LSA,0,"/"); |
| if(!sizeof(targets)) |
| { |
| notify_fail("ls: Keine passenden Verzeichnisse gefunden.\n"); |
| return 0; |
| } |
| |
| // Files sortieren die erste |
| int cmp; |
| if(flags & LS_T) |
| cmp = FILEDATE; |
| else if(flags & LS_S) |
| cmp = FILESIZE; |
| else |
| cmp = BASENAME; |
| |
| closure sort_fun; |
| // Dateinamen aufsteigend sortieren, Groesse und Aenderungsdatum absteigend. |
| if(cmp == BASENAME && !(flags & LS_R) || cmp != BASENAME && (flags & LS_R)) |
| { |
| sort_fun = function int (<int|string>* a, <int|string>* b) { |
| return (a[cmp] > b[cmp]); |
| }; |
| } |
| else |
| { |
| sort_fun = function int (<int|string>* a, <int|string>* b) { |
| return (a[cmp] < b[cmp]); |
| }; |
| } |
| targets = sort_array(targets, sort_fun); |
| |
| // Ausgabeformat bestimmen |
| closure v_read,v_write,creator; |
| if (flags&LS_L) |
| { |
| v_read=VALID_READ_CL; |
| v_write=VALID_WRITE_CL; |
| creator=CREATOR_CL; |
| } |
| string output = ""; |
| // Falls mehr als ein Ziel angegeben wurde, werden zuerst die Ziele |
| // aufgelistet. Anschließend wird in der Schleife der Inhalt von allen Zielen, |
| // die Verzeichnise sind aufgelistet. |
| // Wurde nur ein Ziel angegeben und dies ist eine Datei, wird diese angezeigt. |
| // In der Schleife wird nichts hinzugefügt, weil hier nur Verzeichnisse |
| // aufgelistet werden. |
| if(sizeof(targets) > 1 || targets[0][FILESIZE] >= 0) |
| { |
| string* entries = _ls_list(targets, flags, v_read, v_write, creator); |
| output = sprintf( |
| "\n%d Dateien/Unterverzeichnisse:\n%s\n", |
| sizeof(entries), |
| implode(entries, "")); |
| } |
| foreach(<int|string>* target : targets) |
| { |
| if(target[FILESIZE] != FSIZE_DIR) |
| continue; |
| |
| < <int|string>* >* sub_targets = file_list(({target[FULLNAME] + "/*"}), |
| MODE_LSB, 0, "/"); |
| sub_targets = sort_array(sub_targets, sort_fun); |
| string* entries = _ls_list(sub_targets, flags, v_read, v_write, creator); |
| if(sizeof(entries)) |
| { |
| output += sprintf( |
| "\n%s: Verzeichnis, %d Dateien/Unterverzeichnisse:\n%s\n", |
| target[FULLNAME], |
| sizeof(entries), |
| implode(entries, "")); |
| } |
| else |
| { |
| output += sprintf("\n%s: Leeres Verzeichnis.\n", target[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, |
| (sizeof(arg)>1 ? ({ 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]==FSIZE_DIR) |
| 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; |
| } |
| if (sizeof(args) > 1) |
| args=args[1..]; |
| else |
| break; |
| } |
| return 1; |
| } |
| |
| // ####### |
| //############################### MAN ################################### |
| // ####### |
| |
| /* Sortiert ein Array paarweise, wobei von jedem Wertepaar der erste Wert |
| fuer die Sortierung herangezogen wird. */ |
| private string* SortInPairs(string* arr) { |
| if (!sizeof(arr)) |
| return arr; |
| |
| string** helper = ({}); |
| |
| /* In Sub-Arrays zerlegen, die jeweils ein Wertepaart enthalten: |
| ({s0, s1, s2, s3}) => ({({s0,s1}), ({s2,s3})}) */ |
| int listsize = sizeof(arr); |
| for(int i ; i<listsize ; i+=2) { |
| helper += ({ arr[i..i+1] }); |
| } |
| |
| // Nach dem ersten Element jedes Sub-Arrays sortieren. |
| helper = sort_array(helper, function int (string* h1, string* h2) { |
| return lower_case(h1[0]) > lower_case(h2[0]); |
| }); |
| |
| // Eingabe-Array loeschen und aus den sortierten Wertepaaren neu aufbauen. |
| arr = ({}); |
| foreach(string* h : helper) { |
| arr += h; |
| } |
| |
| return arr; |
| } |
| |
| static int _man(string cmdline) |
| { |
| int i, flags; |
| string *input; |
| |
| string* args = parseargs(_unparsed_args(), &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>"); |
| |
| input = explode(args[0], "/"); |
| |
| /* Wenn das Ergebnis einer vorherigen Suche noch vorliegt und die aktuelle |
| Eingabe als einziges eine einstellige Zahl enthaelt, und diese dann in |
| dem alten Suchergebnis enthalten ist, wird die Eingabe durch das alte |
| Ergebnis ersetzt. <i> wird in dem Fall geloescht. |
| Wenn kein altes Ergebnis gefunden wurde, enthaelt <i> die eingegebene |
| Nummer. */ |
| if (oldman_result && sizeof(input)==1 && sizeof(args)==1 && |
| sizeof(input[0])==1 && (i=to_int(input[0])) && |
| member(oldman_result,i)) |
| { |
| input = ({oldman_result[i,0], oldman_result[i,1]}); |
| i = 0; |
| } |
| /* Ansonsten wenn weder -m, noch -r gesetzt sind und es eine Manpage gibt, |
| die genau der Eingabe entspricht, wird diese verwendet. */ |
| else if (!(flags&(MAN_M|MAN_R)) && sizeof(input)>1) |
| { |
| if (file_size(MAND_DOCDIR+args[0]) >= 0) |
| input = ({input[<1], args[0]}); |
| else |
| input = ({}); |
| } |
| else |
| { |
| /* Soll eine Regexp-Suche durchgefuehrt werden? Dann erstmal den Ausdruck |
| auf Gueltigkeit pruefen. */ |
| if (flags&MAN_R) |
| { |
| flags &= (~MAN_M); |
| if (catch(regexp(({""}), args[0])) || !regexp(({""}), args[0])) |
| { |
| printf("man: Ungueltiger Ausdruck in Maske.\n"); |
| return 1; |
| } |
| } |
| /* Die Ausgabe von locate() liefert ein String-Array, das abwechselnd den |
| Dateinamen der gefundenen Manpage und den vollen Pfad dieser Manpage |
| unterhalb von /doc enthaelt. Beispielsweise ({"Defend","lfun/Defend"}) |
| */ |
| input = ({string *})MAND->locate(args[0], flags&(MAN_M|MAN_R)); |
| // Sortierung case-insensitive, ggf. vorhandene Pfade dabei ignorieren |
| // Wird fuer die spaetere Ausgabe der Liste benoetigt. |
| input = SortInPairs(input); |
| } |
| |
| /* Alte Such-Treffer werden entsorgt. */ |
| oldman_result = 0; |
| |
| /* <i> kann maximal eine einstellige Zahl sein, 1-9, wenn eine solche als |
| einziges Argument eingegeben wurde und kein passendes Ergebnis in einer |
| vorigen Suchanfrage gefunden wurde. |
| |
| <input> kann nur genau dann mehr als 2 Elemente haben, wenn das Ergebnis |
| des Aufrufs MAND->locate() drinsteht. Und nur dann muss ueberhaupt ein |
| hoeheres Wertepaar rausgeschnitten werden, denn wenn <input> bis zu 2 |
| Elemente hat, kann damit direkt weitergearbeitet werden. |
| |
| Beispiel: bei einer Eingabe von "4" wird hier aus <input> das 7. und |
| 8. Element entnommen (Indizes [6..7]). */ |
| if(i && sizeof(input)>2 && sizeof(input) >= i*2) |
| input = input[(i*2-2)..(i*2-1)]; |
| |
| switch (sizeof(input)) |
| { |
| /* <input> leer, nichts brauchbares gefunden. */ |
| case 0: |
| printf("Keine Hilfeseite gefunden fuer '%s'.\n", args[0]); |
| break; |
| |
| /* Genau 2 Elemente enthalten? Dann kann das direkt ausgegeben werden. */ |
| case 2: |
| /* |
| if (flags&MAN_I) |
| { |
| // BRANCH TO MANUALD |
| return 1; |
| } |
| */ |
| printf("Folgende Hilfeseite wurde gefunden: %s\n", input[1]); |
| More(MAND_DOCDIR+input[1], 1); |
| return 1; |
| |
| /* Alles andere: */ |
| default: |
| i = sizeof(input)/2; |
| string* output = allocate(i); |
| |
| // Inhalt: ([ int nummer : string manpage; string manpage_pfad ]) |
| oldman_result = m_allocate(i, 2); |
| |
| while (i) |
| { |
| output[i-1] = input[i*2-2]; |
| m_add(oldman_result, i, input[i*2-2], input[i*2-1]); |
| i--; |
| } |
| |
| // Numerierung ergaenzen |
| foreach(int j : sizeof(output)) |
| { |
| output[j] = sprintf("%d: %s", j+1, output[j]); |
| } |
| |
| int tty_cols = QueryProp(P_TTY_COLS)-2; |
| string list = "Es wurden die folgenden, potentiell passenden Seiten " |
| "gefunden:\n"; |
| |
| // Wer keine Grafik sehen will, bekommt eine andere Anzeige. |
| if (QueryProp(P_NO_ASCII_ART)) |
| { |
| // @ als geschuetztes Leerzeichen verwenden, um einen Umbruch |
| // nach den Nummern zu verhindern. |
| output = map(output, #'regreplace, ": ", ":@", 1); |
| list += break_string(implode(output, " "), tty_cols); |
| list = regreplace(list, ":@", ": ", 1); |
| } |
| else |
| { |
| // Anzahl Spalten ausrechnen: Terminalbreite / Laenge des laengsten |
| // Elements in <output>. Kann der Spaltenmodus von sprintf() an sich |
| // selbst, das liefert aber nicht immer so guenstige Ergebnisse. |
| int maxwidth = max(map(output, #'sizeof)); |
| int tablecols = tty_cols/maxwidth; |
| list += "-"*tty_cols+"\n"+ |
| sprintf("%#-*.*s\n", tty_cols, tablecols, implode(output,"\n"))+ |
| "-"*tty_cols+"\n"; |
| } |
| printf(list); |
| 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(load_object(str))) |
| { |
| 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)); |
| 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; :)); |
| list=sort_array(list, #'<); |
| ausgabe=""; |
| for (i=sizeof(list);i--;) |
| { |
| str=implode(filter(explode(read_file(list[i]),"\n"), |
| (: return $1[0..9]=="#define P_";:)),"\n"); |
| 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 ################################### |
| // ######## |
| |
| // |
| // grep_file: Datei greppen |
| // rexpr: Regular Expression |
| // flags: Flags |
| // |
| |
| private int grep_file(mixed filedata, string rexpr, int flags) |
| { |
| string 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 FSIZE_DIR: return RET_FAIL; |
| case FSIZE_NOFILE: 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); |
| |
| // Bei case-insensitiver Suche das Pattern in Kleinschreibung wandeln |
| if (flags&GREP_I) |
| rexpr=lower_case(rexpr); |
| |
| // Portionsweise das komplette File einlesen. |
| int maxlen = query_limits()[LIMIT_BYTE]; |
| int ptr; |
| bytes read_buffer; |
| bytes data = b""; |
| while (sizeof(read_buffer = read_bytes(fullname, ptr, maxlen))) |
| { |
| data += read_buffer; |
| ptr += sizeof(read_buffer); |
| // die Schleifenbedingung erkennt zwar auch, wenn das File vollstaendig |
| // ist, aber wir koennen den Speicherzugriff auch einsparen und schauen, |
| // ob wir schon alles haben. |
| if (ptr >= filedata[FILESIZE]) |
| break; |
| } |
| // In string konvertieren, wir gehen davon aus, das File ist UTF8-kodiert. |
| string text = to_text(data, "UTF-8"); |
| string *lines = explode(text, "\n"); |
| int count; // Anzahl Zeilen mit Treffern |
| <string|string*> result = ({}); // zutreffende Zeilen |
| int linecount = 1; |
| foreach(string line: lines) |
| { |
| string orig_line = line; |
| // Suche case-insensitive? |
| if (flags&GREP_I) |
| line = lower_case(line); |
| int match = regmatch(line, rexpr) != 0; |
| if (flags&GREP_V) match = !match; // Match ggf. invertieren |
| if (match) |
| { |
| // Ausgeben oder nicht? |
| if (!(flags&GREP_C)) |
| { |
| // Mit Zeilennummer? |
| if (flags&GREP_N) |
| result+=({ sprintf("%4d %s", linecount, orig_line)}); |
| else |
| result+=({orig_line}); |
| } |
| ++count; |
| } |
| ++linecount; |
| } |
| |
| if (count) |
| { |
| // Bei -h werden die Dateinamen unterdrueckt. |
| if (flags&GREP_H) |
| fullname=""; |
| else |
| fullname=sprintf("%s ",fullname); |
| |
| if (flags&GREP_C) |
| result=sprintf("%s%d passende Zeile%s.\n",fullname, count, |
| (count==1?"":"n")); |
| else |
| result = ( (sizeof(fullname) ? fullname + "\n" : "") |
| + implode(result,"\n") + "\n"); |
| |
| // Ergebnis ausgeben in File oder an Magier |
| if (flags&GREP_F) |
| return write_file("/players/"+getuid()+"/grep.out",result); |
| write(result); |
| } |
| 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=(sizeof(args)>1 ? args[1..] : ({}) ); |
| if (flags&GREP_M) |
| { |
| mask=args[<1]; |
| if (sizeof(args) > 2) |
| args = (sizeof(args) > 1 ? args[0..<2] : ({}) ); |
| } |
| if (!sizeof(args)) |
| return USAGE("grep [-" GREP_OPTS |
| "] <regexp> <datei/verz> [<datei2> ... ] [<maske>]"); |
| args=map(args,#'to_filename)-({0}); |
| 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")==FSIZE_DIR |
| || !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; |
| } |