toolcmd.c-Dateireferenz

#include "tool.h"

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

Dieser Graph zeigt, welche Datei direkt oder indirekt diese Datei enthält:

gehe zum Quellcode dieser Datei

Funktionen
int	Xcall (string str)
int	Xcallouts (string str)
int	Xcat (string str)
int	Xcd (string str)
int	Xclean (string str)
int	Xclone (string str)
int	Xuclone (string str)
int	Xcmds (string str)
int	Xdbg (string str)
int	Xdclean (string str)
int	Xddes (string str)
int	Xdes (string str)
int	Xdlook (string str)
int	Xdo (string str)
int	Xdupdate (string str)
int	Xecho (string str)
int	Xeval (string str)
int	Xforall (string str)
int	Xgoto (string str)
int	Xgrep (string str)
int	Xhbeats (string str)
int	Xhead (string str)
int	Xhelp (string str)
int	Xids (string str)
int	Xinfo (string str)
int	Xinherit (string str)
int	Xinventory (string str)
int	Xlag (string str)
int	Xlight (string str)
int	Xload (string str)
int	Xlook (string str)
int	Xlpc (string str)
int	Xman (string str)
int	Xmore (string str)
int	Xmove (string str)
int	Xmsg (string str)
int	Xmtp (string str)
int	Xproc (string str)
int	Xprof (string str)
int	Xprops (string str)
int	Xquit (string str)
int	Xscan (string str)
int	Xset (string str)
int	Xsh (string str)
int	Xsort (string str)
int	Xtail (string str)
int	Xtool (string str)
int	Xtrace (string str)
int	Xtrans (string str)
int	Xupdate (string str)
int	Xuptime (string str)
int	Xwc (string str)
int	cmdavg_compare (string a, string b)
int	Xwho (string opt)

---

Dokumentation der Funktionen

int cmdavg_compare	(	string	a,
		string	b
	)

Definiert in Zeile 1982 der Datei toolcmd.c.

Benutzt x.

{
  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 Xcall

(

string

str

)

Definiert in Zeile 17 der Datei toolcmd.c.

Benutzt cloner, ctime(), Destruct(), ENV, ERR_FILE, error(), FALSE, file(), LPC_FILE, MAX_RECURSION, mixed_to_string(), PIPE_DELETE, pipe_of, pipe_out, PRIVATE_HEADER, rusage(), SECURE2, TK(), TOOL_LOG, TRUE, USAGE2, variable, W, WDLN, WLN und XFindObj().

{
  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))
                  variable=insert_alist("result", res, variable);
      }
    }
    rm(file);
  }
  if(obj) Destruct(obj);
  return TRUE;
}

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

int Xcallouts

(

string

str

)

Definiert in Zeile 86 der Datei toolcmd.c.

Benutzt call_out_info(), delay, file(), i, MAX_RECURSION, mixed_to_string(), PIPE_DELETE, pipe_of, pipe_out, SECURE2, TK(), TMP_FILE, TRUE, USAGE1, WDLN und WLN.

{
  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;
}

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

int Xcat

(

string

str

)

Definiert in Zeile 139 der Datei toolcmd.c.

Benutzt file(), old_explode(), PIPE_FILE, pipe_if, pipe_in, PIPE_MAX, pipe_of, pipe_out, SECURE2, TK(), TRUE, USAGE2, USAGE3, WDLN, WLN und XFindFile().

{
  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;
}

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

int Xcd

(

string

str

)

Definiert in Zeile 176 der Datei toolcmd.c.

Benutzt cloner, dest(), old_explode(), path, PL, SECURE2, TK(), TRUE, USAGE1 und XFindObj().

{
  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(!strlen(path))
    path=str;
  PL->_cd(path);

  return TRUE;
}

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

int Xclean

(

string

str

)

Definiert in Zeile 202 der Datei toolcmd.c.

Benutzt cloner, ENV, env(), ME, PrintShort(), SECURE2, TK(), TRUE, USAGE1 und XFindObj().

{
  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;
}

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

int Xclone

(

string

str

)

Definiert in Zeile 220 der Datei toolcmd.c.

Benutzt cloner, ENV, ERR_FILE, error(), file(), MoveObj(), SECURE2, short_path(), TRUE, USAGE2, variable, W, WDLN, WLN und XFindFile().

{
  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))))
  {
    variable=insert_alist("clone", obj, variable);
    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;
}

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

int Xcmds

(

string

str

)

Definiert in Zeile 279 der Datei toolcmd.c.

Benutzt ALEFT, cloner, cmds, ENV, i, PIPE_DELETE, pipe_of, pipe_out, SECURE2, TK(), TRUE, USAGE1, WDLN, WLN und XFindObj().

{
  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;
}

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

int Xdbg

(

string

str

)

Definiert in Zeile 308 der Datei toolcmd.c.

Benutzt debug_info(), SECURE2, TK(), TRUE, USAGE2 und XFindObj().

{
  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;
}

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

int Xdclean

(

string

str

)

Definiert in Zeile 323 der Datei toolcmd.c.

Benutzt cloner, ENV, env(), ME, PrintShort(), SECURE2, TK(), TRUE, USAGE1 und XFindObj().

{
  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;
}

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

int Xddes

(

string

str

)

Definiert in Zeile 341 der Datei toolcmd.c.

Benutzt Destruct(), ME, PrintShort(), SECURE2, TK(), TRUE, USAGE2 und XFindObj().

{
  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;
}

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

int Xdes

(

string

str

)

Definiert in Zeile 357 der Datei toolcmd.c.

Benutzt Destruct(), PrintShort(), SECURE2, TK(), TRUE, USAGE2 und XFindObj().

{
  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;
}

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

int Xdlook

(

string

str

)

Definiert in Zeile 372 der Datei toolcmd.c.

Benutzt cloner, DeepPrintShort(), NULL, PIPE_DELETE, pipe_of, pipe_out, SECURE2, TK(), TRUE, USAGE1 und XFindObj().

{
  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;
}

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

int Xdo

(

string

str

)

Definiert in Zeile 389 der Datei toolcmd.c.

Benutzt Command(), FALSE, i, SECURE2, strip_explode(), TRUE und USAGE2.

{
  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;
}

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

int Xdupdate

(

string

str

)

Definiert in Zeile 424 der Datei toolcmd.c.

Benutzt Destruct(), file(), i, list, PrintShort(), SECURE2, SUBSTR, TRUE, USAGE2, XFindFile() und XFindObj().

{
  int i, s;
  object obj;
  string file, *list;
  
  SECURE2(TRUE);
  USAGE2(str, "xdu(pdate) <filename>");
  if(!(file=XFindFile(str)))
    return TRUE;
  if(SUBSTR(file, -2, -1)==".c")
    file=SUBSTR(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;
}

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

int Xecho

(

string

str

)

Definiert in Zeile 449 der Datei toolcmd.c.

Benutzt TK(), TRUE und WLN.

{
  TK("Xecho: str: "+(str?str:"(NULL)"));
  WLN(str);
  return TRUE;
}

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

int Xeval

(

string

str

)

Definiert in Zeile 456 der Datei toolcmd.c.

Benutzt cloner, ctime(), Destruct(), ENV, error(), file(), LPC_FILE, MAX_RECURSION, mixed_to_string(), PIPE_DELETE, pipe_of, pipe_out, PRIVATE_HEADER, rusage(), SECURE2, TOOL_LOG, TRUE, USAGE2, variable, W, WDLN und WLN.

{
  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=insert_alist("result", res, variable);
    }
  }
  rm(file);
  if(obj)
    Destruct(obj);
  return TRUE;
}

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

int Xforall

(

string

str

)

Definiert in Zeile 513 der Datei toolcmd.c.

Benutzt Command(), FALSE, i, long_get_dir(), old_explode(), SECURE2, string_replace, TRUE, USAGE2 und WDLN.

{
  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;
}

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

int Xgoto

(

string

str

)

Definiert in Zeile 559 der Datei toolcmd.c.

Benutzt cloner, ENV, M_TPORT, SECURE2, TRUE, USAGE1, XFindFile() und XFindObj().

{
  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;
}

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

int Xgrep

(

string

str

)

Definiert in Zeile 581 der Datei toolcmd.c.

Benutzt FALSE, i, long_get_dir(), old_explode(), PIPE_DELETE, pipe_if, pipe_in, PIPE_MAX, pipe_of, pipe_out, pipe_ovr, SECURE2, TK(), TMP_FILE, TRUE, USAGE2, USAGE3, W, WDLN, WLN, XFile(), XGREP_ICASE, XGREP_REVERT und XGrepFile().

{
  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;
}

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

int Xhbeats

(

string

str

)

Definiert in Zeile 735 der Datei toolcmd.c.

Benutzt cloner, file(), ObjFile(), PIPE_DELETE, pipe_of, pipe_out, RNAME, SECURE2, TK(), TRUE, USAGE1, WDLN und WLN.

{
  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;
}

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

int Xhead

(

string

str

)

Definiert in Zeile 779 der Datei toolcmd.c.

Benutzt FALSE, file(), lines, old_explode(), PIPE_DELETE, PIPE_FILE, pipe_if, pipe_in, PIPE_MAX, pipe_of, pipe_out, SECURE2, TK(), TRUE, USAGE2, WDLN und XFindFile().

{
  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;
}

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

int Xhelp

(

string

str

)

Definiert in Zeile 818 der Datei toolcmd.c.

Benutzt FALSE, SECURE2, TOOL_MANPAGE, TRUE, USAGE1 und XMoreFile().

{
  SECURE2(TRUE);
  USAGE1(str, "xhe(lp)");
  XMoreFile(TOOL_MANPAGE, FALSE);
  return TRUE;
}

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

int Xids

(

string

str

)

Definiert in Zeile 826 der Datei toolcmd.c.

Benutzt SECURE2, TK(), TRUE, USAGE2, WLN und XFindObj().

{
  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;
}

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

int Xinfo

(

string

str

)

Definiert in Zeile 838 der Datei toolcmd.c.

Benutzt FALSE, is_player(), PlayerDomain(), PlayerIP(), PlayerMail(), PlayerRace(), PlayerSnoop(), PlayerStats(), PlayerWho(), SECURE2, TK(), TRUE, USAGE2, WDLN, WLN und XFindObj().

{
  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;
}

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

int Xinherit

(

string

str

)

Definiert in Zeile 863 der Datei toolcmd.c.

Benutzt FALSE, Inheritance(), PIPE_DELETE, pipe_of, SECURE2, strip_explode(), TK(), TRUE, USAGE2, WDLN und XFindObj().

{
  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;
}

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

int Xinventory

(

string

str

)

Definiert in Zeile 896 der Datei toolcmd.c.

Benutzt ARIGHT, cloner, FALSE, FORALL, item, PIPE_DELETE, pipe_of, pipe_out, PrintShort(), SECURE2, short(), TK(), TRUE, USAGE1, WESSEN, who, WLN und XFindObj().

{
  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;
}

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

int Xlag

(

string

str

)

Definiert in Zeile 945 der Datei toolcmd.c.

Benutzt LAG_O_DAEMON, round(), TRUE und WLN.

{
  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;
}

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

int Xlight

(

string

str

)

Definiert in Zeile 994 der Datei toolcmd.c.

Benutzt cloner, ENV, FALSE, SECURE2, TOOL_NAME, TRUE, USAGE1, WDLN und xlight.

{
  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

)

Definiert in Zeile 1012 der Datei toolcmd.c.

Benutzt Destruct(), ERR_FILE, error(), file(), inv(), MoveObj(), SECURE2, TRUE, USAGE2, VOID, W, WDLN, WLN und XFindFile().

{
  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;
}

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

int Xlook

(

string

str

)

Definiert in Zeile 1058 der Datei toolcmd.c.

Benutzt cloner, ENV, file(), PIPE_DELETE, pipe_of, pipe_out, PrintObj(), SECURE2, TK(), TRUE, USAGE1 und XFindObj().

{
  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;
}

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

int Xlpc

(

string

str

)

Definiert in Zeile 1082 der Datei toolcmd.c.

Benutzt cloner, Destruct(), ENV, error(), file(), LPC_FILE, MAX_RECURSION, mixed_to_string(), PRIVATE_HEADER, rusage(), SECURE2, TRUE, USAGE2, variable, W, WDLN und WLN.

{
  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,
                                  "#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){"+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=insert_alist("result", res, variable);
    }
  }
  rm(file);
  if(obj)
    Destruct(obj);
  return TRUE;
}

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

int Xman

(

string

str

)

Definiert in Zeile 1130 der Datei toolcmd.c.

Benutzt FALSE, manpath, SECURE2, TRUE, USAGE2, W, WLN und XMoreFile().

{
  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;
}

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

int Xmore

(

string

str

)

Definiert in Zeile 1154 der Datei toolcmd.c.

Benutzt FALSE, file(), moreoffset, pipe_if, pipe_in, SECURE2, strip_explode(), TK(), TRUE, USAGE2, USAGE3, WDLN, XFindFile() und XMoreFile().

{
  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;
}

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

int Xmove

(

string

str

)

Definiert in Zeile 1196 der Datei toolcmd.c.

Benutzt FALSE, MoveObj(), SECURE2, TRUE, USAGE2 und XFindObj().

{
  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;
}

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

int Xmsg

(

string

str

)

Definiert in Zeile 1209 der Datei toolcmd.c.

Benutzt cloner, CRNAME, FALSE, input_to(), msgto, pipe_if, pipe_in, PIPE_MAX, PrintShort(), SECURE2, shout(), TK(), TRUE, USAGE1, WDLN und XFindObj().

{
  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;
}

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

int Xmtp

(

string

str

)

Definiert in Zeile 1261 der Datei toolcmd.c.

Benutzt FALSE, file(), MASTER, ME, old_explode(), SECURE2, TRUE, USAGE2, WDLN und XmtpScript().

{
  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;
}

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

int Xproc

(

string

str

)

Definiert in Zeile 1292 der Datei toolcmd.c.

Benutzt old_explode(), SECURE2, TOOL_PATH, TRUE, USAGE1 und WLN.

{
  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;
}

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

int Xprof

(

string

str

)

Definiert in Zeile 1345 der Datei toolcmd.c.

Benutzt ALEFT, ARIGHT, data, Destruct(), FALSE, ME, SECURE2, TMP_FILE, TRUE, USAGE2, WDLN, XFindFile(), XFindObj(), XMoreFile(), XPROF_FILE und XPROF_MACRO.

{
  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;
}

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

int Xprops

(

string

str

)

Definiert in Zeile 1430 der Datei toolcmd.c.

Benutzt DumpProperties(), flag, old_explode(), SECURE2, TK(), TRUE, USAGE2 und XFindObj().

{
  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;
}

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

int Xquit

(

string

str

)

Definiert in Zeile 1461 der Datei toolcmd.c.

Benutzt cloner, ENV, SECURE2, TRUE und USAGE1.

{
  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

)

Definiert in Zeile 1472 der Datei toolcmd.c.

Benutzt FALSE, SECURE2, TRUE, USAGE1, VarCheck(), variable, W und WLN.

{
  int i, s;
  string *oldvars, *desvars;
  
  SECURE2(TRUE);
  USAGE1(str, "xsc(an)");
  W("Destructed variable(s): ");
  oldvars=(string*)variable[0];
  VarCheck(FALSE);
  desvars=oldvars-(string*)variable[0];
  s=sizeof(desvars);
  for(i=0; i<s; i++)
  {
    W("$"+desvars[i]);
    if(i<s-1)
      W(", ");
  }
  WLN("");
  return TRUE;
}

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

int Xset

(

string

str

)

Definiert in Zeile 1494 der Datei toolcmd.c.

Benutzt cloner, ENV, FALSE, member_array(), name, ObjFile(), remove_alist(), SECURE2, TRUE, USAGE1, VarCheck(), variable, WDLN, WLN und XFindObj().

{
  int i;
  mixed obj;
  string name, tmp;
  
  SECURE2(TRUE);
  USAGE1(str, "xse(t) [$<name>=<object>]");
  if(str) {
    if(member_array(str,({"$me","$m","$here","$h"}))!=-1)
      WDLN("Sorry, this is a reserved variable ["+str+"]");
    else if(sscanf(str, "$%s=%s", name, tmp))
    {
      if(obj=XFindObj(tmp))
      {
                variable=insert_alist(name, obj, variable);
                WLN(" $"+name+"="+ObjFile(obj));
      }
    }
    else
      return FALSE;
  }
  else
  {
    VarCheck(FALSE);
    WLN("Current settings:");
    for(i=0; i<sizeof(variable[0]); i++) {
      if(variable[1][i])
                WLN(" $"+variable[0][i]+"="+ObjFile(variable[1][i]));
      else variable=remove_alist(variable[0][i--], variable);
    }
    WLN(" $me="+ObjFile(cloner));
    WLN(" $here="+ObjFile(ENV(cloner)));
  }
  return TRUE;
}

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

int Xsh

(

string

str

)

Definiert in Zeile 1531 der Datei toolcmd.c.

Benutzt NULL, old_explode(), scriptline, scriptsize, SECURE2, TRUE, USAGE1, WDLN, XExecFile() und XFindFile().

{
  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;
}

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

int Xsort

(

string

str

)

Definiert in Zeile 1553 der Datei toolcmd.c.

Benutzt FALSE, file(), old_explode(), PIPE_FILE, pipe_if, pipe_in, PIPE_MAX, pipe_of, pipe_out, SECURE2, TK(), TRUE, USAGE2, USAGE3, WDLN und XFindFile().

{
  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;
}

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

int Xtail

(

string

str

)

Definiert in Zeile 1605 der Datei toolcmd.c.

Benutzt file(), lines, old_explode(), PIPE_FILE, pipe_if, pipe_in, PIPE_MAX, pipe_of, pipe_out, SECURE2, TK(), TRUE, WDLN, WLN und XFindFile().

{
  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;
}

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

int Xtool

(

string

str

)

Definiert in Zeile 1672 der Datei toolcmd.c.

Benutzt AUTOLOAD_ARGS, cloner, destruct(), Destruct(), FALSE, ME, MODE, MODE_ECHO, MODE_FIRST, MODE_INVCHECK, MODE_OFF, MODE_ON, MODE_PROTECT, MODE_SCANCHK, MODE_SHORT, MODE_VARCHECK, morelines, move(), restore_object(), SAVE_FILE, save_object(), SECURE2, TK(), TOOL_NAME, TOOL_NEWS, TOOL_PATH, TOOL_TITLE, TRUE, USAGE1, VarCheck(), WDLN, WLN und XMoreFile().

{
  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;
}

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

int Xtrace

(

string

str

)

Definiert in Zeile 1810 der Datei toolcmd.c.

Benutzt file(), PrintShort(), SECURE2, short_path(), SUBSTR, TRACE_LEVEL, TRUE, USAGE1, WDLN und XFindObj().

{
  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=SUBSTR(file, 1, -1);
    traceprefix(file);
    trace(TRACE_LEVEL);
  }
  return TRUE;
}

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

int Xtrans

(

string

str

)

Definiert in Zeile 1833 der Datei toolcmd.c.

Benutzt cloner, CRNAME, ENV, MoveObj(), SECURE2, TRUE, USAGE2, WDLN und XFindObj().

{
  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;
}

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

int Xuclone

(

string

str

)

Definiert in Zeile 247 der Datei toolcmd.c.

Benutzt cloner, Destruct(), ENV, ERR_FILE, error(), file(), MoveObj(), SECURE2, short_path(), TRUE, USAGE2, variable, W, WDLN, WLN und XFindFile().

{
  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=insert_alist("clone", obj, variable);
    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;
}

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

int Xupdate

(

string

str

)

Definiert in Zeile 1852 der Datei toolcmd.c.

Benutzt Destruct(), file(), PrintShort(), pure_file_name, SECURE2, SUBSTR, TRUE, USAGE2, WDLN, XFindFile() und XFindObj().

{
  object obj;
  string file;
  
  SECURE2(TRUE);
  USAGE2(str, "xup(date) <filename>");
  if(!(file=XFindFile(str)))
    return TRUE;
  if(SUBSTR(file, -2, -1)==".c")
    file=SUBSTR(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;
}

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

int Xuptime

(

string

str

)

Definiert in Zeile 1873 der Datei toolcmd.c.

Benutzt TRUE.

{
  return TRUE;
}

int Xwc

(

string

str

)

Definiert in Zeile 1878 der Datei toolcmd.c.

Benutzt FALSE, file(), lines, pipe_if, pipe_in, PIPE_MAX, SECURE2, TK(), TRUE, USAGE1, USAGE2, WDLN, WLN und XFindFile().

{
  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]!=' '&&strlen(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]!=' '&&strlen(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+=strlen(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;
}

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

int Xwho

(

string

opt

)

Definiert in Zeile 1991 der Datei toolcmd.c.

Benutzt FALSE, ME, pipe_of, pipe_out, SECURE2, TK(), TRUE, USAGE1 und WLN.

{
  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;
}

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