| /* |
| * MGtool-1.0 |
| * File: toolcmds.c |
| * Maintainer: Kirk@MorgenGrauen |
| */ |
| |
| /*------------------------------------------*/ |
| /* the original Xtool is copyrighted by Hyp */ |
| /*------------------------------------------*/ |
| |
| #include "tool.h" |
| |
| /*---------------------------------------------------------------------- |
| * command functions |
| */ |
| |
| int Xcall(string str) |
| { |
| object obj, callobj; |
| string file, callstr, callfun, callexpr, error, errlog; |
| int *ru1, *ru2, xtime; |
| mixed res; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xcall <object>-><function>(<arguments>)"); |
| TK("Xcall: str: "+(str?str:"(NULL)")); |
| if(sscanf(str, "%s->%s(%s", callstr, callfun, callexpr)!=3) |
| return FALSE; |
| if(!(callobj=XFindObj(callstr))) |
| return TRUE; |
| else |
| { |
| #if 0 |
| write_file(TOOL_LOG, |
| sprintf("%s (%s) xcall %s (env: %s)\n",ctime(time()), |
| getuid(cloner),str,object_name(environment(cloner)))); |
| #endif |
| file=LPC_FILE+".c"; |
| if(file_size(file)>0) |
| rm(file); |
| if(obj=find_object(LPC_FILE)) |
| Destruct(obj); |
| obj=0; |
| write_file(file, |
| "#include <properties.h>\n"+ |
| "#include <thing/properties.h>\n"+ |
| "#include <defines.h>\n"+ |
| "#include <wizlist.h>\n"+ |
| "#include <moving.h>\n"+ |
| "#include \"/secure/wizlevels.h\"\n"+ |
| (file_size(PRIVATE_HEADER)>=0?"#include \""+PRIVATE_HEADER+"\"\n":"")+ |
| "mixed get(string str){return previous_object()->XFindObj(str);}\n"+ |
| "mixed eval(object obj,mixed me,mixed here){return obj->"+callfun+"("+callexpr+";}\n"); |
| errlog = ERR_FILE; |
| if(file_size(errlog)>0) |
| rm(errlog); |
| if(error=catch((LPC_FILE)->__nixgibts__())) |
| W("Error: "+error[1..]); |
| else |
| { |
| obj=find_object(LPC_FILE); |
| ru1=rusage(); |
| error=catch(res=(mixed)obj->eval(callobj, cloner, ENV(cloner))); |
| ru2=rusage(); |
| if(error) |
| W("Error: "+error[1..]); |
| else |
| { |
| xtime=ru2[0]-ru1[0]+ru2[1]-ru1[1]; |
| WDLN("Evaluation time: "+(xtime<0 ? 0 : xtime)+" ms"); |
| PIPE_DELETE(pipe_of); |
| if(pipe_out&&pipe_of) |
| write_file(pipe_of,mixed_to_string(res, MAX_RECURSION)+"\n"); |
| else |
| WLN("Result: "+mixed_to_string(res, MAX_RECURSION)); |
| if(objectp(res)) |
| m_add(variable, "result", res); |
| } |
| } |
| rm(file); |
| } |
| if(obj) Destruct(obj); |
| return TRUE; |
| } |
| |
| int Xcallouts(string str) |
| { |
| object obj; |
| mixed callouts, args; |
| string fun, tmp, file; |
| int delay, i, s; |
| |
| SECURE2(TRUE); |
| TK("Xcallouts: str: "+(str?str:"(NULL)")); |
| if(!pipe_out) |
| { |
| USAGE1(str, "xcallo(uts) [search pattern]"); |
| file=TMP_FILE; |
| if(file_size(file)>0) |
| rm(file); |
| if(!str) |
| str="^\\[~/"; |
| else if(!regexp(({"dummy"}), str)) |
| { |
| WDLN("Bad regular expression"); |
| return TRUE; |
| } |
| } |
| else |
| { |
| USAGE1(str, "xcallo(uts)"); |
| if(str&&str!="") |
| { |
| WDLN("More arguments than expected"); |
| return TRUE; |
| } |
| } |
| callouts=call_out_info(); |
| s=sizeof(callouts); |
| PIPE_DELETE(pipe_of); |
| for(i=0; i<s; i++) |
| { |
| if(callouts[i]&&pointerp(callouts[i])) |
| { |
| tmp=sprintf("%O %Os %O (%s)",callouts[i][0],callouts[i][2], |
| callouts[i][1],(sizeof(callouts[i])>3? |
| mixed_to_string(callouts[i][3], |
| MAX_RECURSION):"0")); |
| if(pipe_out&&pipe_of) |
| write_file(pipe_of,tmp+"\n"); |
| else |
| if(sizeof(regexp(({tmp}), str))) |
| WLN(tmp); |
| } |
| } |
| return TRUE; |
| } |
| |
| int Xcat(string str) |
| { |
| string *tmp,file; |
| int s; |
| |
| SECURE2(TRUE); |
| TK("Xcat: str: "+str); |
| if(!pipe_in) |
| { |
| USAGE2(str, "xcat <file>"); |
| if(!(file=XFindFile(str))) |
| { |
| WDLN("Can't find file"); |
| return TRUE; |
| } |
| } |
| else |
| { |
| if(str&&str!="-") |
| USAGE3("xcat -"); |
| |
| if (file_size(file=pipe_if)<0) |
| { |
| WDLN("Missing input to xcat"); |
| return TRUE; |
| } |
| } |
| tmp=old_explode(read_file(file,0,PIPE_MAX),"\n"); |
| if(pipe_in&&pipe_if==PIPE_FILE) |
| rm(PIPE_FILE); |
| if (pipe_out&&pipe_of) |
| write_file(pipe_of,implode(tmp,"\n")+"\n"); |
| else |
| WLN(implode(tmp,"\n")); |
| return TRUE; |
| } |
| |
| int Xcd(string str) |
| { |
| object dest; |
| string path; |
| |
| SECURE2(TRUE); |
| USAGE1(str, "xcd [object]"); |
| TK("Xcd: str: "+(str?str:"(NULL)")); |
| if(!str) |
| { |
| if(!(path=(string)cloner->QueryProp("start_home"))) |
| path="/"; |
| } |
| else if((dest=XFindObj(str,1))) |
| path="/"+implode(old_explode(object_name(dest),"/")[0..<2],"/"); |
| else |
| path=""; |
| |
| TK("Xcd: path: "+(path?path:"(NULL)")); |
| if(!sizeof(path)) |
| path=str; |
| PL->_cd(path); |
| |
| return TRUE; |
| } |
| |
| int Xclean(string str) |
| { |
| object env; |
| |
| SECURE2(TRUE); |
| USAGE1(str, "xcle(an) [object]"); |
| TK("Xclean: str: "+(str?str:"(NULL)")); |
| if(!str) |
| env=ENV(cloner); |
| if(env||(env=XFindObj(str))) |
| { |
| PrintShort("Cleaning: ", env); |
| filter(filter(all_inventory(env), #'is_not_player),//' |
| "Destruct", ME); |
| } |
| return TRUE; |
| } |
| |
| int Xclone(string str) |
| { |
| object obj; |
| string file, errlog, error; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xclo(ne) <filename>"); |
| if(!(file=XFindFile(str))) return TRUE; |
| errlog=ERR_FILE; |
| if(file_size(errlog)>0) rm(errlog); |
| WLN("Clone: "+short_path(file)); |
| if(!(error=catch(obj=clone_object(file)))) |
| { |
| m_add(variable, "clone", obj); |
| if(!MoveObj(obj, ENV(cloner), TRUE)) |
| WDLN("Cannot move object into this room"); |
| else if(!obj->QueryNoGet()) |
| { |
| if(!MoveObj(obj, cloner, TRUE)) |
| WDLN("Cannot move object into your inventory"); |
| } |
| } |
| else |
| W("Error: "+error[1..]); |
| return TRUE; |
| } |
| |
| int Xuclone(string str) |
| { |
| object obj; |
| string file, errlog, error; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xuclo(ne) <filename>"); |
| if(!(file=XFindFile(str))) return TRUE; |
| errlog=ERR_FILE; |
| if(file_size(errlog)>0) rm(errlog); |
| if(obj=find_object(file)) { |
| Destruct(obj); |
| WLN("Update and clone: "+short_path(file)); |
| } |
| else |
| WLN("Clone: "+short_path(file)); |
| if(!(error=catch(obj=clone_object(file)))) |
| { |
| variable["clone"] = obj; |
| if(!MoveObj(obj, ENV(cloner), TRUE)) |
| WDLN("Cannot move object into this room"); |
| else if(!obj->QueryNoGet()) |
| { |
| if(!MoveObj(obj, cloner, TRUE)) |
| WDLN("Cannot move object into your inventory"); |
| } |
| } |
| else |
| W("Error: "+error[1..]); |
| return TRUE; |
| } |
| |
| int Xcmds(string str) |
| { |
| object obj; |
| mixed *cmds; |
| int i, s; |
| |
| SECURE2(TRUE); |
| USAGE1(str, "xcm(ds) [object]"); |
| TK("Xcmds: str: "+(str?str:"(NULL)")); |
| if(!str) |
| obj=ENV(cloner); |
| else if(!(obj=XFindObj(str))) |
| { |
| WDLN("Can't find object"); |
| return TRUE; |
| } |
| s=sizeof(cmds=query_actions(cloner,1|2|4|8|16)); |
| PIPE_DELETE(pipe_of); |
| for(i=0; i<s; i+=5) |
| if(cmds[i+3]==obj) |
| if(pipe_out&&pipe_of) |
| write_file(pipe_of,ALEFT(cmds[i]+" ", 15, ".")+ |
| (cmds[i+2] ? " * " : " . ")+cmds[i+4]+"()\n"); |
| else |
| WLN(ALEFT(cmds[i]+" ", 15, ".")+ |
| (cmds[i+2] ? " * " : " . ")+cmds[i+4]+"()"); |
| return TRUE; |
| } |
| |
| int Xdbg(string str) |
| { |
| object obj; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xdb(g) <object>"); |
| TK("Xdbg: str: "+(str?str:"(NULL)")); |
| if((obj=XFindObj(str))) |
| { |
| debug_info(1, obj); |
| debug_info(0, obj); |
| } |
| return TRUE; |
| } |
| |
| int Xdclean(string str) |
| { |
| object env; |
| |
| SECURE2(TRUE); |
| USAGE1(str, "xdc(lean) [object]"); |
| TK("Xdclean: str: "+(str?str:"(NULL)")); |
| if(!str) |
| env=ENV(cloner); |
| if(env||(env=XFindObj(str))) |
| { |
| PrintShort("Deep cleaning: ", env); |
| filter(filter(all_inventory(env), #'is_not_player, ME),//' |
| "DeepClean", ME); |
| } |
| return TRUE; |
| } |
| |
| int Xddes(string str) |
| { |
| object obj; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xdd(es) <object>"); |
| TK("Xddes: str: "+(str?str:"(NULL)")); |
| if((obj=XFindObj(str))) |
| { |
| PrintShort("Deep destruct: ", obj); |
| filter(deep_inventory(obj), "Destruct", ME); |
| Destruct(obj); |
| } |
| return TRUE; |
| } |
| |
| int Xdes(string str) |
| { |
| object obj; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xde(s) <object>"); |
| TK("Xdes: str: "+(str?str:"(NULL)")); |
| if((obj=XFindObj(str))) |
| { |
| PrintShort("Destruct: ",obj); |
| Destruct(obj); |
| } |
| return TRUE; |
| } |
| |
| int Xdlook(string str) |
| { |
| object obj; |
| |
| SECURE2(TRUE); |
| USAGE1(str, "xdl(ook) [object]"); |
| TK("Xdlook: str: "+(str?str:"(NULL)")); |
| if(!str) |
| obj=cloner; |
| if(obj||(obj=XFindObj(str))) |
| { |
| PIPE_DELETE(pipe_of); |
| DeepPrintShort(obj,NULL,NULL,(pipe_out&&pipe_of)?pipe_of:""); |
| } |
| return TRUE; |
| } |
| |
| int Xdo(string str) |
| { |
| int i, n, s; |
| string *strs, cmd; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xdo [<number1>#]<command1>[;[<number2>#]<command2>] ..."); |
| if(!str||str==""||!(s=sizeof(strs=strip_explode(str, ";")))) |
| return FALSE; |
| for(i=0; i<s; i++) |
| { |
| if(strs[i]) |
| { |
| switch(sscanf(strs[i], "%d#%s", n, cmd)) |
| { |
| case 0: |
| if(!Command(strs[i])) return TRUE; |
| break; |
| case 1: |
| if(cmd&&(!Command(cmd))) return TRUE; |
| break; |
| case 2: |
| n= n<1 ? 1 : n; |
| if(cmd) |
| { |
| while(n--) |
| if(!Command(cmd)) return TRUE; |
| } |
| break; |
| } |
| } |
| } |
| return TRUE; |
| } |
| |
| int Xdupdate(string str) |
| { |
| int i, s; |
| object obj; |
| string file, *list; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xdu(pdate) <filename>"); |
| if(!(file=XFindFile(str))) |
| return TRUE; |
| if(file[<2..<1]==".c") |
| file=file[0..<3]; |
| if(obj=XFindObj(file)) |
| { |
| PrintShort("Deep updating: ", obj); |
| list=inherit_list(obj); |
| for(s=sizeof(list); i<s; i++) |
| { |
| if(obj=find_object(list[i])) |
| Destruct(obj); |
| } |
| } |
| return TRUE; |
| } |
| |
| int Xecho(string str) |
| { |
| TK("Xecho: str: "+(str?str:"(NULL)")); |
| WLN(str); |
| return TRUE; |
| } |
| |
| int Xeval(string str) |
| { |
| object obj; |
| string file, error; |
| int *ru1, *ru2, xtime; |
| mixed res; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xev(al) <expression>"); |
| file=LPC_FILE+".c"; |
| if(file_size(file)>0) |
| rm(file); |
| if(obj=find_object(LPC_FILE)) |
| Destruct(obj); |
| #if 0 |
| write_file(TOOL_LOG, |
| sprintf("%s (%s) xeval %s\n", |
| ctime(time()),getuid(cloner),str)); |
| #endif |
| write_file(file, |
| "#include <properties.h>\n"+ |
| "#include <thing/properties.h>\n"+ |
| "#include <defines.h>\n"+ |
| "#include <wizlist.h>\n"+ |
| "#include <moving.h>\n"+ |
| "#include \"/secure/wizlevels.h\"\n"+ |
| (file_size(PRIVATE_HEADER)>=0?"#include \""+PRIVATE_HEADER+"\"\n":"")+ |
| "get(str){return previous_object()->XFindObj(str);}\n"+ |
| "eval(me,here){return "+str+";}"); |
| if(error=catch(obj=clone_object(file))) |
| W("Error: "+error[1..]); |
| else |
| { |
| ru1=rusage(); |
| error=catch(res=(mixed)obj->eval(cloner, ENV(cloner))); |
| ru2=rusage(); |
| if(error) |
| W("Error: "+error[1..]); |
| else |
| { |
| xtime=ru2[0]-ru1[0]+ru2[1]-ru1[1]; |
| WDLN("Evaluation time: "+(xtime<0 ? 0 : xtime)+" ms"); |
| PIPE_DELETE(pipe_of); |
| if(pipe_out&&pipe_of) |
| write_file(pipe_of,mixed_to_string(res,MAX_RECURSION)+"\n"); |
| else |
| WLN("Result: "+mixed_to_string(res, MAX_RECURSION)); |
| if(objectp(res)) |
| variable["result"] = res; |
| } |
| } |
| rm(file); |
| if(obj) |
| Destruct(obj); |
| return TRUE; |
| } |
| |
| int Xforall(string str) |
| { |
| int i, s, t, u; |
| string pat, cmd, arg, *strs, *files, fh, fr, fe, ft, ff; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xfo(rall) <filepattern> <command>"); |
| if(sscanf(str, "%s %s", pat, arg)!=2) |
| return FALSE; |
| files=long_get_dir(pat, FALSE); |
| if(!(s=sizeof(files))) |
| { |
| WDLN("No matching files found"); |
| return TRUE; |
| } |
| strs=old_explode(files[0], "/"); |
| fh="/"; |
| if(t=sizeof(strs)-1) |
| fh+=implode(strs[0..t-1], "/"); |
| for(i=0; i<s; i++) |
| { |
| ft=old_explode(files[i], "/")[t]; |
| if((u=sizeof(strs=old_explode(ft, ".")))&&--u) |
| { |
| ff=implode(strs[0..u-1], "."); |
| fr=fh+"/"+ff; |
| fe=strs[u]; |
| } |
| else |
| { |
| fe=""; |
| ff=ft; |
| fr=files[i]; |
| } |
| cmd=string_replace(arg, "!!", files[i]); |
| cmd=string_replace(cmd, "!e", fe); |
| cmd=string_replace(cmd, "!f", ff); |
| cmd=string_replace(cmd, "!h", fh); |
| cmd=string_replace(cmd, "!r", fr); |
| cmd=string_replace(cmd, "!t", ft); |
| if(!(Command(cmd))) |
| break; |
| } |
| return TRUE; |
| } |
| |
| int Xgoto(string str) |
| { |
| object obj, tmp; |
| |
| SECURE2(TRUE); |
| USAGE1(str, "xgo(to) [object]"); |
| if(!str) str="~/workroom"; |
| if(!(obj=XFindObj(str))) |
| { |
| if(!(str=XFindFile(str))) |
| return TRUE; |
| if(catch(call_other(str, "???"))) |
| return TRUE; |
| obj=find_object(str); |
| } |
| tmp=obj; |
| while(obj&&living(obj)) |
| obj=ENV(obj); |
| cloner->move(obj ? obj : tmp, M_TPORT); |
| return TRUE; |
| } |
| |
| int Xgrep(string str) |
| { |
| int i, s, t, mode; |
| string *files, *ts; |
| |
| SECURE2(TRUE); |
| TK("Xgrep: str: "+(str?str:"(NULL)")); |
| mode=0; |
| if(!pipe_in) |
| { |
| USAGE2(str, "xgr(ep) [-i] [-v] <regexp> <filepattern>"); |
| if(!(ts=old_explode(str, " "))||!(s=sizeof(ts))) |
| return FALSE; |
| while(ts[0][0]=='-') |
| { |
| if(s<3) |
| { |
| WDLN("Too few arguments to xgrep"); |
| return FALSE; |
| } |
| switch(ts[0]) |
| { |
| case "-v": |
| mode|=XGREP_REVERT; |
| ts=ts[1..]; |
| s--; |
| break; |
| case "-i": |
| mode|=XGREP_ICASE; |
| ts=ts[1..]; |
| s--; |
| break; |
| case "-vi": |
| case "-iv": |
| mode|=XGREP_REVERT; |
| mode|=XGREP_ICASE; |
| ts=ts[1..]; |
| s--; |
| break; |
| default: |
| WDLN("Unknown option "+ts[0]+" given to xgrep"); |
| return FALSE; |
| } |
| } |
| str=implode(ts[0..s-2], " "); |
| } |
| else |
| { |
| if(!((ts=old_explode(str, " "))&&(s=sizeof(ts)))) |
| USAGE3("xgr(ep) [-i] [-v] <regexp>"); |
| while(ts[0][0]=='-') |
| { |
| if(s<2) |
| { |
| WDLN("Too few arguments to xgrep"); |
| return FALSE; |
| } |
| switch(ts[0]) |
| { |
| case "-v": |
| mode|=XGREP_REVERT; |
| ts=ts[1..]; |
| s--; |
| break; |
| case "-i": |
| mode|=XGREP_ICASE; |
| ts=ts[1..]; |
| s--; |
| break; |
| case "-iv": |
| case "-vi": |
| mode|=XGREP_REVERT; |
| mode|=XGREP_ICASE; |
| ts=ts[1..]; |
| s--; |
| break; |
| default: |
| WDLN("Unknown option "+ts[0]+" given to xgrep"); |
| return FALSE; |
| } |
| } |
| str=implode(ts[0..s-1], " "); |
| } |
| |
| if(mode&XGREP_ICASE) |
| str=lower_case(str); |
| if(!(regexp(({"dummy"}), str))) |
| { |
| WDLN("Bad regular expression"); |
| return TRUE; |
| } |
| if(!pipe_in) |
| { |
| if(file_size(TMP_FILE)>0) |
| rm(TMP_FILE); |
| if((t=sizeof(files=long_get_dir(XFile(ts[s-1]), FALSE)))&& |
| (file_size(files[0])>=0)) |
| { |
| for(i=0; i<t; i++) |
| XGrepFile(str, files[i], mode); |
| if(pipe_out&&pipe_of) |
| { |
| PIPE_DELETE(pipe_of); |
| if(!pipe_ovr) |
| { |
| write_file(pipe_of,read_file(TMP_FILE,0,PIPE_MAX)); |
| rm(TMP_FILE); |
| } |
| else |
| rename(TMP_FILE,pipe_of); |
| } |
| else |
| { |
| W(read_file(TMP_FILE,0,PIPE_MAX)); |
| rm(TMP_FILE); |
| } |
| } |
| else |
| WDLN("Cannot read file(s)"); |
| } |
| else |
| { |
| string *tmp; |
| if(file_size(pipe_if)<0) |
| { |
| WDLN("Missing input to xgrep"); |
| return TRUE; |
| } |
| TK("Xgrep: str: "+str+" mode: "+mode); |
| s=sizeof(tmp=old_explode(read_file(pipe_if,0,PIPE_MAX),"\n")); |
| PIPE_DELETE(pipe_of); |
| for(i=0;i<s;i++) |
| { |
| // TK(tmp[i]+"<->"+str); |
| if(sizeof(regexp(({(mode&XGREP_ICASE?lower_case(tmp[i]):tmp[i])}),str))) |
| { |
| // TK("Xgrep: matched!"); |
| if(!(mode&XGREP_REVERT)) |
| if(pipe_out&&pipe_of) |
| write_file(pipe_of,tmp[i]+"\n"); |
| else |
| WLN(tmp[i]); |
| } |
| else |
| if(mode&XGREP_REVERT) |
| if(pipe_out&&pipe_of) |
| write_file(pipe_of,tmp[i]+"\n"); |
| else |
| WLN(tmp[i]); |
| } |
| } |
| return TRUE; |
| } |
| |
| int Xhbeats(string str) |
| { |
| object obj; |
| object *hbeatinfo; |
| string tmp, file; |
| int i, s; |
| |
| SECURE2(TRUE); |
| TK("Xhbeats: str: "+(str?str:"(NULL)")); |
| if(!pipe_out) |
| { |
| USAGE1(str, "xhb(eats) [search pattern]"); |
| if(!str) |
| str=RNAME(cloner); |
| else if(!regexp(({"dummy"}), str)) |
| { |
| WDLN("Bad regular expression"); |
| return TRUE; |
| } |
| } |
| else |
| { |
| USAGE1(str,"xhb(eats)"); |
| if(str&&str!="") |
| { |
| WDLN("More arguments than expected"); |
| return TRUE; |
| } |
| } |
| s=sizeof(hbeatinfo=heart_beat_info()); |
| PIPE_DELETE(pipe_of); |
| for(i=0; i<s; i++) |
| if(hbeatinfo[i]&&objectp(hbeatinfo[i])) |
| { |
| tmp=ObjFile(hbeatinfo[i]); |
| if(sizeof(regexp(({tmp}), str))) |
| if(pipe_out&&pipe_of) |
| write_file(pipe_of, tmp+"\n"); |
| else |
| WLN(tmp); |
| } |
| return TRUE; |
| } |
| |
| int Xhead(string str) |
| { |
| int lines; |
| string *tmp, file; |
| |
| SECURE2(TRUE); |
| TK("Xhead: str: "+(str?str:"(NULL)")); |
| if(!pipe_in) |
| { |
| USAGE2(str, "xhead <-#> <file>"); |
| if(sscanf(str,"-%d %s",lines,file)!=2) |
| return FALSE; |
| if(!(file=XFindFile(file))) |
| return FALSE; |
| } |
| else |
| { |
| USAGE2(str, "xhead <-#>"); |
| if(sscanf(str,"-%d",lines)!=1) |
| return FALSE; |
| if (file_size(file=pipe_if)<0) |
| { |
| WDLN("Missing input to xhead"); |
| return TRUE; |
| } |
| } |
| tmp=old_explode(read_file(file,0,PIPE_MAX),"\n")[0..lines-1]; |
| if(pipe_in&&pipe_if==PIPE_FILE) |
| rm(PIPE_FILE); |
| if (pipe_out&&pipe_of) |
| { |
| PIPE_DELETE(pipe_of); |
| write_file(pipe_of,implode(tmp,"\n")+"\n"); |
| } |
| else |
| WDLN(implode(tmp,"\n")); |
| return TRUE; |
| } |
| |
| int Xhelp(string str) |
| { |
| SECURE2(TRUE); |
| USAGE1(str, "xhe(lp)"); |
| XMoreFile(TOOL_MANPAGE, FALSE); |
| return TRUE; |
| } |
| |
| int Xids(string str) |
| { |
| object obj; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xid(s) <object>"); |
| TK("Xids: str: "+(str?str:"(NULL)")); |
| if((obj=XFindObj(str))) |
| WLN("UID=\""+getuid(obj)+"\" / EUID=\""+geteuid(obj)+"\""); |
| return TRUE; |
| } |
| |
| int Xinfo(string str) |
| { |
| object obj; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xinf(o) <object>"); |
| TK("Xinfo: str: "+(str?str:"(NULL)")); |
| if((obj=XFindObj(str))) |
| { |
| if(is_player(obj)) |
| { |
| WLN(PlayerWho(obj)); |
| WLN(PlayerMail(obj, FALSE)); |
| WLN(PlayerIP(obj, FALSE)); |
| WLN(PlayerRace(obj, FALSE)); |
| WLN(PlayerDomain(obj, FALSE)); |
| WLN(PlayerStats(obj, FALSE)); |
| WLN(PlayerSnoop(obj, FALSE)); |
| } |
| else |
| WDLN("Sorry, this is not a player"); |
| } |
| return TRUE; |
| } |
| |
| int Xinherit(string str) |
| { |
| int s; |
| object obj; |
| string *strs, *inlist; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xinh(erit) <object> [function]"); |
| TK("Xinherit: str: "+str); |
| if(!(strs=strip_explode(str, " "))) |
| return FALSE; |
| if(obj=XFindObj(strs[0])) |
| { |
| inlist=inherit_list(obj); |
| s=sizeof(inlist); |
| while(s--) |
| { |
| if(catch(call_other(inlist[s], "???"))) |
| { |
| WDLN("Failed to load all inheritance objects"); |
| return TRUE; |
| } |
| } |
| obj=find_object(inlist[0]); |
| PIPE_DELETE(pipe_of); |
| if(sizeof(strs)==1) |
| Inheritance(obj ,0 ,""); |
| else |
| Inheritance(obj, strs[1], ""); |
| } |
| return TRUE; |
| } |
| |
| int Xinventory(string str) |
| { |
| int i, short; |
| object item; |
| mixed who; |
| |
| SECURE2(TRUE); |
| USAGE1(str, "xi [-s] [player]"); |
| TK("Xinventory: str: "+str); |
| short=0; |
| who=cloner; |
| if(str&&str!="") |
| { |
| if(str=="-s") |
| { |
| short=1; |
| who=cloner; |
| } |
| else if(sscanf(str,"-s %s",who)) |
| { |
| short=1; |
| who=XFindObj(who); |
| } |
| else if(sscanf(str,"%s",who)) |
| { |
| short=0; |
| who=XFindObj(who); |
| } |
| else |
| who=cloner; |
| } |
| if(!who) |
| return FALSE; |
| PIPE_DELETE(pipe_of); |
| if(!(pipe_out&&pipe_of)) |
| WLN(who->name(WESSEN)+" Inventory:"+(short?" (short)":"")); |
| if(!short) |
| if(pipe_out&&pipe_of) |
| FORALL(item, who) PrintShort(ARIGHT(++i+". ", 4, " "), item, pipe_of); |
| else |
| FORALL(item, who) PrintShort(ARIGHT(++i+". ", 4, " "), item); |
| else |
| if(pipe_out&&pipe_of) |
| FORALL(item, who) write_file(pipe_of,++i+". ["+object_name(item)+"]\n"); |
| else |
| FORALL(item, who) WLN(++i+". ["+object_name(item)+"]"); |
| return TRUE; |
| } |
| |
| int Xlag(string str) |
| { |
| int i; |
| float *lag; |
| object daemon; |
| string lags; |
| |
| if(file_size(LAG_O_DAEMON+".c")<=0) |
| { |
| WLN("Sorry, lag-o-daemon is missing!"); |
| return TRUE; |
| } |
| |
| LAG_O_DAEMON->MachHin(); |
| if(!(daemon=find_object(LAG_O_DAEMON))) |
| lag=({-1.0,-1.0,-1.0}); |
| else |
| lag=(float *)daemon->read_lag_data(); |
| lags="Letzte 60 min: "; |
| if(lag[0]>=0.0) |
| { |
| for(i=round(lag[0])-1;i>=0;i--) |
| lags+="#"; |
| lags+=" ("+sprintf("%.1f",lag[0])+"%)"; |
| } |
| else |
| lags+="N/A"; |
| lags+="\nLetzte 15 min: "; |
| if(lag[1]>=0.0) |
| { |
| for(i=round(lag[1])-1;i>=0;i--) |
| lags+="#"; |
| lags+=" ("+sprintf("%.1f",lag[1])+"%)"; |
| } |
| else |
| lags+="N/A"; |
| lags+="\nLetzte Minute: "; |
| if(lag[2]>=0.0) |
| { |
| for(i=round(lag[2])-1;i>=0;i--) |
| lags+="#"; |
| lags+=" ("+sprintf("%.1f",lag[2])+"%)"; |
| } |
| else |
| lags+="N/A"; |
| WLN(lags); |
| return TRUE; |
| } |
| |
| int Xlight(string str) |
| { |
| int s, addlight; |
| |
| SECURE2(TRUE); |
| USAGE1(str, "xli(ght) [light]"); |
| if(str) |
| { |
| if(!sscanf(str, "%d", addlight)) |
| return FALSE; |
| xlight+=addlight; |
| cloner->AddIntLight(addlight); |
| } |
| WDLN("Current light levels: "+TOOL_NAME+"="+xlight+", room="+ |
| ENV(cloner)->QueryIntLight()); |
| return TRUE; |
| } |
| |
| int Xload(string str) |
| { |
| int i, f; |
| object obj, *inv, vroom; |
| string file, errlog, error, *strs; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xloa(d) <filename>"); |
| if(!(file=XFindFile(str))) |
| return TRUE; |
| errlog=ERR_FILE; |
| if(file_size(errlog)>0) |
| rm(errlog); |
| if(obj=find_object(file)) |
| { |
| if(catch(call_other(VOID, "???"))) |
| { |
| WDLN("Error: cannot find "+VOID+" to rescue players"); |
| return TRUE; |
| } |
| else |
| vroom = find_object(VOID); |
| if(inv=filter(all_inventory(obj), #'is_player, ME))//' |
| for(i=0; i<sizeof(inv); i++) |
| MoveObj(inv[i], vroom, TRUE); |
| Destruct(obj); |
| WLN("Update and load: "+file); |
| } |
| else |
| WLN("Load: "+file); |
| if(error=catch(call_other(file, "???"))) |
| { |
| W("Error: "+error[1..]); |
| if(vroom) |
| tell_object(vroom, "*** Failed to load room. You are in the void!\n"); |
| } |
| else if(inv) |
| { |
| obj=find_object(file); |
| for(i=0; i<sizeof(inv); i++) |
| if(inv[i]) |
| MoveObj(inv[i], obj, TRUE); |
| } |
| return TRUE; |
| } |
| |
| int Xlook(string str) |
| { |
| object obj; |
| string st; |
| string file; |
| |
| SECURE2(TRUE); |
| USAGE1(str, "xloo(k) [object]"); |
| TK("Xlook: str: "+str); |
| PIPE_DELETE(pipe_of); |
| file = pipe_out&&pipe_of ? pipe_of : ""; |
| if(str&&str!="") |
| { |
| if((obj=XFindObj(str))) |
| PrintObj(obj,file); |
| } |
| else |
| { |
| obj=ENV(cloner); |
| PrintObj(obj,file); |
| } |
| return TRUE; |
| } |
| |
| int Xlpc(string str) |
| { |
| object obj; |
| string file, error; |
| int *ru1, *ru2, time; |
| mixed res; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xlp(c) <lpc code>"); |
| file=LPC_FILE+".c"; |
| if(file_size(file)>0) |
| rm(file); |
| if(obj=find_object(LPC_FILE)) |
| Destruct(obj); |
| write_file(file, |
| "#pragma no_warn_missing_return,strong_types,warn_deprecated,rtt_checks\n" |
| "#include <properties.h>\n" |
| "#include <thing/properties.h>\n" |
| "#include <defines.h>\n" |
| "#include <wizlist.h>\n" |
| "#include <moving.h>\n" |
| "#include \"/secure/wizlevels.h\"\n" |
| +(file_size(PRIVATE_HEADER)>=0?"#include \""+PRIVATE_HEADER+"\"\n":"")+ |
| "object get(string str){return previous_object()->XFindObj(str);}\n"+ |
| "mixed eval(mixed me, mixed here){"+str+"}"); |
| if(error=catch(obj=clone_object(file))) |
| W("Error: "+error[1..0]); |
| else |
| { |
| ru1=rusage(); |
| error=catch(res=(mixed)obj->eval(cloner, ENV(cloner))); |
| ru2=rusage(); |
| if(error) |
| W("Error: "+error[1..]); |
| else |
| { |
| time=ru2[0]-ru1[0]+ru2[1]-ru1[1]; |
| WDLN("Evaluation time: "+(time<0 ? 0 : time)+" ms"); |
| WLN("Result: "+mixed_to_string(res, MAX_RECURSION)); |
| if(objectp(res)) |
| variable["result"] = res; |
| } |
| } |
| rm(file); |
| if(obj) |
| Destruct(obj); |
| return TRUE; |
| } |
| |
| int Xman(string str) |
| { |
| string manpage; |
| int i, found; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xma(n) <manpage>"); |
| W("Man: "); |
| for(i=0, found=0; i<sizeof(manpath); i++) |
| { |
| manpage=manpath[i]+str; |
| if(file_size(manpage)>=0) |
| { |
| WLN(manpage); |
| XMoreFile(manpage, FALSE); |
| found=1; |
| break; |
| } |
| } |
| if(!found) |
| WLN("- no help available -"); |
| return TRUE; |
| } |
| |
| int Xmore(string str) |
| { |
| string *args, file; |
| int line; |
| |
| SECURE2(TRUE); |
| TK("Xmore: str: "+str); |
| if (!pipe_in) |
| { |
| USAGE2(str, "xmor(e) <filename> [start]"); |
| switch(sizeof(args=strip_explode(str, " "))) |
| { |
| case 1: |
| moreoffset=1; |
| break; |
| case 2: |
| sscanf(args[1], "%d", line); |
| moreoffset= line>0 ? line : 1; |
| break; |
| default: |
| return FALSE; |
| } |
| if(file=XFindFile(args[0])) |
| XMoreFile(file, TRUE); |
| } |
| else |
| { |
| if(file_size(pipe_if)<0) |
| { |
| WDLN("Missing input to xmore"); |
| return TRUE; |
| } |
| if (!str||str=="") |
| line=1; |
| else if (sscanf(str, "%d", line)!=1) |
| USAGE3("xmor(e) [start]"); |
| moreoffset= line>0 ? line : 1; |
| XMoreFile(pipe_if, TRUE); |
| } |
| return TRUE; |
| } |
| |
| int Xmove(string str) |
| { |
| object obj1, obj2; |
| string what, into; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xmov(e) <object> into <object>"); |
| if((sscanf(str, "%s into %s", what, into)==2)&& |
| (obj1=XFindObj(what))&&(obj2=XFindObj(into))) |
| MoveObj(obj1, obj2, FALSE); |
| return TRUE; |
| } |
| |
| int Xmsg(string str) |
| { |
| string tmp; |
| |
| SECURE2(TRUE); |
| TK("Xmsg: str: "+str); |
| USAGE1(str, "xms(g) [to <object>|all]"); |
| if(!str||str=="") |
| { |
| WDLN("Send message into room"); |
| say("Message from "+CRNAME(cloner)+":\n"); |
| if(pipe_in&&pipe_if) |
| say(read_file(pipe_if,0,PIPE_MAX)); |
| else |
| { |
| WDLN("End message with \".\" or \"**\""); |
| input_to("XMsgSay"); |
| } |
| return TRUE; |
| } |
| else if(sscanf(str, "to %s", tmp)) |
| { |
| if(msgto=XFindObj(tmp)) |
| { |
| PrintShort("Send message to: ", msgto); |
| tell_object(msgto, "Message from "+CRNAME(cloner)+" to you:\n"); |
| if(pipe_in&&pipe_if) |
| tell_object(msgto,read_file(pipe_if,0,PIPE_MAX)); |
| else |
| { |
| WDLN("End message with \".\" or \"**\""); |
| input_to("XMsgTell"); |
| } |
| } |
| return TRUE; |
| } |
| else if(str=="all") |
| { |
| WDLN("Send message to all players"); |
| shout("Message from "+CRNAME(cloner)+" to all:\n"); |
| if(pipe_in&&pipe_if) |
| shout(read_file(pipe_if,0,PIPE_MAX)); |
| else |
| { |
| WDLN("End message with \".\" or \"**\""); |
| input_to("XMsgShout"); |
| } |
| return TRUE; |
| } |
| return FALSE; |
| } |
| |
| int Xmtp(string str) |
| { |
| int s; |
| string *strs, opt, dir, file; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xmt(p) [options] <directory> <filename>"); |
| s=sizeof(strs=old_explode(str, " ")); |
| if(s<2) |
| return FALSE; |
| else if(s==2) |
| opt=""; |
| else |
| opt=implode(strs[0..s-3], " "); |
| if(!(dir="/"+(string)MASTER->valid_read(strs[s-2], geteuid(), |
| "get_dir", ME))) { |
| WDLN("No permission to open directory for reading"); |
| return TRUE; |
| } |
| if(!(file="/"+(string)MASTER->valid_write(strs[s-1], geteuid(), |
| "write_file", ME))) { |
| WDLN("No permission to open script file for writing"); |
| return TRUE; |
| } |
| if(file_size(dir)!=-2 || file_size(file)==-2) |
| return FALSE; |
| XmtpScript(dir, file, opt); |
| WDLN("Done"); |
| return TRUE; |
| } |
| |
| int Xproc(string str) |
| { |
| int s; |
| string *strs; |
| |
| SECURE2(TRUE); |
| USAGE1(str, "xproc [-c] [-l] [-m] [-u] [-v]"); |
| |
| if(file_size(TOOL_PATH+"/proc")!=-2) |
| { |
| WLN("Sorry, no /proc information available!"); |
| return TRUE; |
| } |
| |
| if(!str||str==""||!(s=sizeof(strs=old_explode(str, " ")))) |
| { |
| WLN("Load averages:"); |
| cat(TOOL_PATH+"/proc/loadavg"); |
| return TRUE; |
| } |
| |
| while(s=sizeof(strs)) |
| { |
| switch(strs[0]) |
| { |
| case "-c": |
| WLN("CPU info:"); |
| cat(TOOL_PATH+"/proc/cpuinfo"); |
| break; |
| case "-l": |
| WLN("Load averages:"); |
| cat(TOOL_PATH+"/proc/loadavg"); |
| break; |
| case "-m": |
| WLN("Memory usage:"); |
| cat(TOOL_PATH+"/proc/meminfo"); |
| break; |
| case "-u": |
| WLN("Uptime:"); |
| cat(TOOL_PATH+"/proc/uptime"); |
| break; |
| case "-v": |
| WLN("Version:"); |
| cat(TOOL_PATH+"/proc/version"); |
| break; |
| default: |
| WLN("Unknown option: "+strs[0]); |
| } |
| strs=strs[1..]; |
| } |
| return TRUE; |
| } |
| |
| int Xprof(string str) |
| { |
| string *funcs, inh, tmp; |
| mixed *data, *d; |
| mapping xpr; |
| object obj; |
| int i, rn; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xprof <<-c>|<-C> <file>>|<object>"); |
| if(str[0..2]=="-c "||str[0..2]=="-C ") |
| { |
| rn=(str[1]=='C'); |
| if(str=XFindFile(str[3..])) |
| { |
| inh=str=str[0..<3]; |
| if(obj=find_object(inh)) |
| Destruct(obj); |
| if(catch(call_other(inh,"???"))) |
| return TRUE; |
| obj=find_object(inh); |
| if(rn) |
| { |
| inh+=".xprof.c"; |
| rm(inh); |
| str+=".c"; |
| rename(str, inh); |
| } |
| else |
| { |
| str=XPROF_FILE; |
| rm(str); |
| } |
| tmp="inherit \""+inh+"\";\n#include \""+XPROF_MACRO+"\"\n"; |
| funcs=m_indices(mkmapping(functionlist(obj, 0x08000001)))-({"__INIT"}); |
| for(i=sizeof(funcs); i--;) |
| tmp+="F("+funcs[i]+",\""+funcs[i]+"\","+ |
| "(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9))\n"; |
| write_file(str, tmp); |
| WDLN("Done"); |
| } |
| } |
| else if(obj=XFindObj(str)) |
| { |
| if(xpr=(mapping)obj->__query_xprof_data__()) |
| { |
| funcs=m_indices(xpr); |
| data=m_values(xpr); |
| rm(TMP_FILE); |
| str="Evaluation cost per function:\nNAME "+ |
| " CALLS | TOT.EXCL. TOT.INCL. | REL.EXCL. REL.INCL.\n"; |
| for(i=sizeof(funcs); i--;) |
| { |
| if(d=data[i]) { |
| funcs[i]=ALEFT(""+funcs[i]+" ",25,".")+ARIGHT(" "+d[0], 6,".")+" | "+ |
| ARIGHT(" "+d[1],10,".") +" "+ARIGHT(" "+d[3],10,".")+" | "+ |
| ARIGHT(" "+d[1]/d[0],9,".") +" "+ARIGHT(" "+d[3]/d[0],9,"."); |
| } |
| } |
| str+=implode(sort_array(funcs, "string_compare", ME),"\n")+"\n"; |
| write_file(TMP_FILE,str); |
| str="\nElapsed time per function:\nNAME "+ |
| " CALLS | TOT.EXCL. TOT.INCL. | REL.EXCL. REL.INCL.\n"; |
| funcs=m_indices(xpr); |
| for(i=sizeof(funcs); i--;) |
| { |
| if(d=data[i]) |
| { |
| funcs[i]=ALEFT(""+funcs[i]+" ",25,".")+ARIGHT(" "+d[0], 6,".")+" | "+ |
| ARIGHT(" "+(d[2]+5)/10+"ms",10,".")+" "+ |
| ARIGHT(" "+(d[4]+5)/10+"ms",10,".")+" | "+ |
| ARIGHT(" "+d[2]/d[0]+"us",9,".")+" "+ |
| ARIGHT(" "+d[4]/d[0]+"us",9,"."); |
| } |
| } |
| str+=implode(sort_array(funcs, "string_compare", ME),"\n")+"\n"; |
| write_file(TMP_FILE,str); |
| XMoreFile(TMP_FILE, FALSE); |
| } |
| else |
| WDLN("No profiling information available"); |
| } |
| return TRUE; |
| } |
| |
| int Xprops(string str) |
| { |
| int i, s, flag; |
| object obj; |
| string *tmp; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xprop(s) [-f|-m] <object>"); |
| TK("Xprops: str: "+str); |
| tmp=old_explode(str," "); |
| switch(tmp[0]) |
| { |
| case "-f": |
| { |
| flag = 1; |
| tmp=tmp[1..]; |
| break; |
| } |
| case "-m": |
| { |
| flag = 2; |
| tmp=tmp[1..]; |
| break; |
| } |
| } |
| str=implode(tmp," "); |
| if((obj=XFindObj(str))) |
| DumpProperties(obj,flag); |
| return TRUE; |
| } |
| |
| int Xquit(string str) |
| { |
| SECURE2(TRUE); |
| USAGE1(str, "xqu(it)"); |
| str=object_name(ENV(cloner)); |
| if(member(str, '#')<0) |
| cloner->set_home(str); |
| cloner->quit(); |
| return TRUE; |
| } |
| |
| int Xscan(string str) |
| { |
| SECURE2(TRUE); |
| USAGE1(str, "xsc(an)"); |
| W("Destructed variable(s): "); |
| string* oldvars=m_indices(variable); |
| VarCheck(FALSE); |
| string* desvars=oldvars-m_indices(variable); |
| desvars = map(desvars, function string (string k) |
| {return "$"+k;} ); |
| W(CountUp(desvars)); |
| WLN(""); |
| return TRUE; |
| } |
| |
| int Xset(string str) |
| { |
| int i; |
| mixed obj; |
| string name, tmp; |
| |
| SECURE2(TRUE); |
| USAGE1(str, "xse(t) [$<name>=<object>]"); |
| if(str) { |
| if(member(({"$me","$m","$here","$h"}),str)!=-1) |
| WDLN("Sorry, this is a reserved variable ["+str+"]"); |
| else if(sscanf(str, "$%s=%s", name, tmp)) |
| { |
| if(obj=XFindObj(tmp)) |
| { |
| variable[name] = obj; |
| WLN(" $"+name+"="+ObjFile(obj)); |
| } |
| } |
| else |
| return FALSE; |
| } |
| else |
| { |
| VarCheck(FALSE); |
| WLN("Current settings:"); |
| foreach(string key, mixed val : variable) |
| { |
| if (val) |
| WLN(" $"+key+"="+ObjFile(val)); |
| else |
| m_delete(variable, key); |
| } |
| WLN(" $me="+ObjFile(cloner)); |
| WLN(" $here="+ObjFile(ENV(cloner))); |
| } |
| return TRUE; |
| } |
| |
| int Xsh(string str) |
| { |
| SECURE2(TRUE); |
| USAGE1(str, "xsh <filename>"); |
| if(scriptline) |
| { |
| WDLN("Cannot execute another script file until last execution has ended"); |
| return TRUE; |
| } |
| if(!(str=XFindFile(str))) |
| return TRUE; |
| str=read_file(str, 1, 1000); |
| if(!(scriptline=old_explode(str, "\n"))) |
| { |
| WDLN("Bad script file"); |
| return TRUE; |
| } |
| scriptsize=sizeof(scriptline); |
| XExecFile(NULL); |
| return TRUE; |
| } |
| |
| int Xsort(string str) |
| { |
| string *tmp,file; |
| int s,reverse; |
| |
| SECURE2(TRUE); |
| TK("Xsort: str: "+str); |
| if(!pipe_in) |
| { |
| USAGE2(str, "xso(rt) [-r] [file]"); |
| if(!(tmp=old_explode(str, " "))||(s=sizeof(tmp))>2) |
| return FALSE; |
| if(tmp[0]=="-r") |
| if(s==1) |
| return FALSE; |
| else |
| { |
| reverse=TRUE; |
| tmp=tmp[1..]; |
| } |
| else if(s>1) |
| return FALSE; |
| if(!(file=XFindFile(tmp[0]))) |
| { |
| WDLN("Can't find file"); |
| return TRUE; |
| } |
| } |
| else |
| { |
| if(str&&str!="") |
| if(str=="-r") |
| reverse=TRUE; |
| else |
| USAGE3("xso(rt) [-r]"); |
| if (file_size(file=pipe_if)<0) |
| { |
| WDLN("Missing input to xsort"); |
| return TRUE; |
| } |
| } |
| tmp=old_explode(read_file(file,0,PIPE_MAX),"\n"); |
| if(pipe_in&&pipe_if==PIPE_FILE) |
| rm(PIPE_FILE); |
| tmp=sort_array(tmp,reverse?#'<:#'>); |
| if (pipe_out&&pipe_of) |
| write_file(pipe_of,implode(tmp,"\n")+"\n"); |
| else |
| WDLN(implode(tmp,"\n")); |
| return TRUE; |
| } |
| |
| int Xtail(string str) |
| { |
| string *tmp,file,sign; |
| int lines; |
| |
| if (!str) { |
| WDLN("Missing input to xtail"); |
| return TRUE; |
| } |
| |
| sign="-"; |
| lines=10; |
| SECURE2(TRUE); |
| TK("Xtail: str: "+str); |
| if(!pipe_in) |
| { |
| if(sscanf(str,"-%d %s",lines,file)==2) |
| sign="-"; |
| else if(sscanf(str,"+%d %s",lines,file)==2) |
| sign="+"; |
| else |
| file=str; |
| |
| if(!(file=XFindFile(file))) |
| { |
| WDLN("Can't find file"); |
| return TRUE; |
| } |
| } |
| else |
| { |
| if(sscanf(str,"-%d",lines)==1) |
| sign="-"; |
| else if(sscanf(str,"+%d",lines)==1) |
| sign="+"; |
| if (file_size(file=pipe_if)<0) |
| { |
| WDLN("Missing input to xtail"); |
| return TRUE; |
| } |
| } |
| |
| if(sign=="-") |
| { |
| if(!lines) |
| return TRUE; |
| } |
| |
| if(file_size(file)>50000) |
| { |
| WDLN("File too large"); |
| return TRUE; |
| } |
| |
| if(sign=="+") |
| tmp=old_explode(read_file(file,0,PIPE_MAX),"\n")[lines..]; |
| else |
| tmp=old_explode(read_file(file,0,PIPE_MAX),"\n")[<lines..]; |
| if(pipe_in&&pipe_if==PIPE_FILE) |
| rm(PIPE_FILE); |
| if (pipe_out&&pipe_of) |
| write_file(pipe_of,implode(tmp,"\n")+"\n"); |
| else |
| WLN(implode(tmp,"\n")); |
| return TRUE; |
| } |
| |
| int Xtool(string str) |
| { |
| int m; |
| string tmp; |
| object obj; |
| |
| SECURE2(TRUE); |
| TK("Xtool: str: "+str); |
| USAGE1(str, "xto(ol) [update|first=<on|off>|protect=<on|off>|"+ |
| "invcheck=<on|off>|\n"+ |
| "\t\tvarcheck=<on|off>|scanchk=<on|off>|short=<on|off>|\n"+ |
| "\t\techo=<on|off>|more=<amount>|kill|news|save|load|reset]"); |
| if(str&&str!="") |
| { |
| if(sscanf(str, "more=%d", m)) |
| { |
| if(m<5) |
| WDLN("Sorry, amount of lines should be more then 5"); |
| else |
| { |
| WDLN("Setting amount of displayed lines to "+m); |
| morelines=m; |
| } |
| } |
| else |
| switch(str) |
| { |
| case "update": |
| if(obj=find_object(TOOL_PATH)) |
| Destruct(obj); |
| if(catch(obj=clone_object(TOOL_PATH))) |
| WLN("Updating "+TOOL_TITLE+" failed!"); |
| else |
| obj->update_tool(AUTOLOAD_ARGS, cloner); |
| return TRUE; |
| break; |
| case "first=on": |
| MODE_ON(MODE_FIRST); |
| move(cloner); |
| WDLN("Automatic moving into pole position of inventory turned on"); |
| break; |
| case "first=off": |
| MODE_OFF(MODE_FIRST); |
| WDLN("Automatic moving into pole position of inventory turned off"); |
| break; |
| case "protect=on": |
| MODE_ON(MODE_PROTECT); |
| WDLN("Protection from forces and illegal moves turned on"); |
| break; |
| case "protect=off": |
| MODE_OFF(MODE_PROTECT); |
| WDLN("Protection from forces and illegal moves turned off"); |
| break; |
| case "invcheck=on": |
| MODE_ON(MODE_INVCHECK); |
| WDLN("Automatic checking for new objects in inventory turned on"); |
| break; |
| case "invcheck=off": |
| MODE_OFF(MODE_INVCHECK); |
| WDLN("Automatic checking for new objects in inventory turned off"); |
| break; |
| case "varcheck=on": |
| MODE_ON(MODE_VARCHECK); |
| VarCheck(TRUE); |
| WDLN("Automatic variable checking turned on"); |
| break; |
| case "varcheck=off": |
| MODE_OFF(MODE_VARCHECK); |
| WDLN("Automatic variable checking turned off"); |
| break; |
| case "scanchk=on": |
| MODE_ON(MODE_SCANCHK); |
| WDLN("Scan check turned on"); |
| break; |
| case "scanchk=off": |
| MODE_OFF(MODE_SCANCHK); |
| WDLN("Scan check turned off"); |
| break; |
| case "echo=on": |
| MODE_ON(MODE_ECHO); |
| WDLN("Echoing of multiple command execution turned on"); |
| break; |
| case "echo=off": |
| MODE_OFF(MODE_ECHO); |
| WDLN("Echoing of multiple command execution turned off"); |
| break; |
| case "short=on": |
| MODE_ON(MODE_SHORT); |
| WDLN("Use of short descriptions turned on"); |
| break; |
| case "short=off": |
| MODE_OFF(MODE_SHORT); |
| WDLN("Use of short descriptions turned off"); |
| break; |
| case "kill": |
| WDLN(TOOL_NAME+" selfdestructs"); |
| destruct(ME); |
| break; |
| case "news": |
| XMoreFile(TOOL_NEWS, FALSE); |
| break; |
| case "reset": |
| WDLN("Resetting "+TOOL_TITLE); |
| ME->__INIT(); |
| break; |
| case "load": |
| if(file_size(SAVE_FILE+".o")>0) |
| { |
| WDLN("Loading "+TOOL_TITLE+" settings"); |
| restore_object(SAVE_FILE); |
| } |
| else |
| WDLN("Sorry, cannot find file to load settings"); |
| break; |
| case "save": |
| WDLN("Saving "+TOOL_TITLE+" settings"); |
| save_object(SAVE_FILE); |
| break; |
| default: |
| return FALSE; |
| } |
| } |
| else |
| { |
| WLN(TOOL_TITLE+" settings:"); |
| tmp= (" first .... = "+(MODE(MODE_FIRST) ? "on\n" : "off\n")); |
| tmp+=(" protect .. = "+(MODE(MODE_PROTECT) ? "on\n" : "off\n")); |
| tmp+=(" invcheck . = "+(MODE(MODE_INVCHECK) ? "on\n" : "off\n")); |
| tmp+=(" varcheck . = "+(MODE(MODE_VARCHECK) ? "on\n" : "off\n")); |
| tmp+=(" scanchk .. = "+(MODE(MODE_SCANCHK) ? "on\n" : "off\n")); |
| tmp+=(" echo ..... = "+(MODE(MODE_ECHO) ? "on\n" : "off\n")); |
| tmp+=(" short .... = "+(MODE(MODE_SHORT) ? "on\n" : "off\n")); |
| tmp+=(" more ..... = "+morelines); |
| WLN(sprintf("%-80#s", tmp)); |
| } |
| return TRUE; |
| } |
| |
| int Xtrace(string str) |
| { |
| string file; |
| object obj; |
| |
| SECURE2(TRUE); |
| USAGE1(str, "xtrac(e) <object>"); |
| if(!str||str=="") |
| { |
| trace(0); |
| WDLN("Ending trace ["+short_path("/"+traceprefix(0))+"]"); |
| } |
| else if(obj=XFindObj(str)) |
| { |
| PrintShort("Tracing: ", obj); |
| file=object_name(obj); |
| file=file[1..<1]; |
| traceprefix(file); |
| trace(TRACE_LEVEL); |
| } |
| return TRUE; |
| } |
| |
| int Xtrans(string str) |
| { |
| object obj; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xtran(s) <object>"); |
| if((obj=XFindObj(str))&&ENV(obj)) |
| { |
| tell_room(ENV(obj), CRNAME(obj)+" vanishes.\n"); |
| tell_room(ENV(cloner), CRNAME(obj)+ |
| " is teleported into this room by "+CRNAME(cloner)+".\n"); |
| MoveObj(obj, ENV(cloner), TRUE); |
| tell_object(obj, "You've been teleported to "+CRNAME(cloner)+".\n"); |
| } |
| else |
| WDLN("Failed to teleport object"); |
| return TRUE; |
| } |
| |
| int Xupdate(string str) |
| { |
| object obj; |
| string file; |
| |
| SECURE2(TRUE); |
| USAGE2(str, "xup(date) <filename>"); |
| if(!(file=XFindFile(str))) |
| return TRUE; |
| if(file[<2.. <1]==".c") |
| file=file[0.. <3]; |
| if((obj=XFindObj(file))&&(obj=find_object(pure_file_name(obj)))) |
| { |
| PrintShort("Updating: ", obj); |
| Destruct(obj); |
| } |
| else |
| WDLN("Object not found"); |
| return TRUE; |
| } |
| |
| int Xuptime(string str) |
| { |
| return TRUE; |
| } |
| |
| int Xwc(string str) |
| { |
| string file; |
| string tmp, *tmp2; |
| int i, chars, words, lines, nchars, nwords, nlines; |
| |
| SECURE2(TRUE); |
| TK("Xwc: str: "+str); |
| chars=words=lines=FALSE; |
| if(!pipe_in) |
| { |
| USAGE2(str, "xwc [-cwl] <file>"); |
| if(str[0]=='-') |
| { |
| while((str=str[1..])[0]!=' '&&sizeof(str)) |
| switch(str[0]) |
| { |
| case 'c': |
| chars=TRUE; |
| break; |
| case 'w': |
| words=TRUE; |
| break; |
| case 'l': |
| lines=TRUE; |
| break; |
| default: |
| return FALSE; |
| } |
| str=str[1..]; |
| } |
| if(!(file=XFindFile(str))) |
| { |
| WDLN("Can't find file"); |
| return TRUE; |
| } |
| } |
| else |
| { |
| USAGE1(str,"xwc [-cwl]"); |
| if(str) |
| if(str[0]=='-') |
| { |
| while((str=str[1..])[0]!=' '&&sizeof(str)) |
| switch(str[0]) |
| { |
| case 'c': |
| chars=TRUE; |
| break; |
| case 'w': |
| words=TRUE; |
| break; |
| case 'l': |
| lines=TRUE; |
| break; |
| default: |
| return FALSE; |
| } |
| } |
| else |
| return FALSE; |
| if(file_size(file=pipe_if)<0) |
| { |
| WDLN("Missing input to xwc"); |
| return TRUE; |
| } |
| } |
| if(!(chars|words|lines)) |
| chars=words=lines=TRUE; |
| nlines=nwords=nchars=0; |
| tmp=read_file(file,0,PIPE_MAX); |
| tmp2=explode(tmp,"\n"); |
| if(lines) |
| { |
| nlines=sizeof(tmp2); |
| if(tmp2[<1]==""&&nlines>1) |
| nlines--; |
| } |
| if(words) |
| for(i=sizeof(tmp2)-1;i>=0;i--) |
| { |
| TK(sprintf("%O",tmp2[i])); |
| if(tmp2[i]!="") |
| nwords+=sizeof(regexplode(tmp2[i],"[ ]")-({""," "," "})); |
| TK(sprintf("%O",regexplode(tmp2[i],"[ ]")-({""," "," "}))); |
| TK("nwords: "+nwords); |
| } |
| if(chars) |
| for(i=sizeof(tmp2)-1;i>=0;i--) |
| nchars+=sizeof(tmp2[i])+1; |
| tmp2=0; |
| tmp=""; |
| if(lines) |
| tmp+=sprintf("%7d",nlines)+" "; |
| if(words) |
| tmp+=sprintf("%7d",nwords)+" "; |
| if(chars) |
| tmp+=sprintf("%7d",nchars)+" "; |
| if(file!=pipe_if) |
| tmp+=file; |
| WLN(tmp); |
| return TRUE; |
| } |
| |
| int cmdavg_compare(string a, string b) |
| { |
| int x,y; |
| string dum; |
| sscanf(a,"%s cmdavg: %d",dum,x); |
| sscanf(b,"%s cmdavg: %d",dum,y); |
| return x==y?0:(x>y?1:-1); |
| } |
| |
| int Xwho(string opt) |
| { |
| string *strs,str,func; |
| |
| SECURE2(TRUE); |
| TK("Xwho: opt: \""+opt+"\""); |
| USAGE1(opt, "xwh(o) [mail|ip|race|guild|domain|stats|snoop]"); |
| func="string_compare"; |
| if(!opt||opt=="") |
| strs=map(users(), "PlayerWho", ME); |
| else |
| switch(opt) |
| { |
| case "mail": |
| strs=map(users(), "PlayerMail", ME, TRUE); |
| break; |
| case "ip": |
| strs=map(users(), "PlayerIP", ME, TRUE); |
| break; |
| case "race": |
| case "guild": |
| strs=map(users(), "PlayerRace", ME, TRUE); |
| break; |
| case "domain": |
| strs=map(users(), "PlayerDomain", ME, TRUE); |
| break; |
| case "stat": |
| case "stats": |
| strs=map(users(), "PlayerStats", ME, TRUE); |
| break; |
| case "snoop": |
| strs=map(users(), "PlayerSnoop", ME, TRUE); |
| break; |
| case "cmdavg": |
| strs=map(users(), "PlayerCmdAvg", ME, TRUE); |
| func="cmdavg_compare"; |
| break; |
| default: |
| return FALSE; |
| } |
| strs=sort_array(strs, func, ME); |
| if(pipe_out&&pipe_of) |
| write_file(pipe_of,implode(strs,"\n")+"\n"); |
| else |
| WLN(implode(strs,"\n")); |
| return TRUE; |
| } |