t_base.c-Dateireferenz

#include "teller.h"
#include <properties.h>
#include <language.h>
#include <defines.h>
#include <moving.h>
#include <terminal.h>
Include-Abhängigkeitsdiagramm für t_base.c:
Dieser Graph zeigt, welche Datei direkt oder indirekt diese Datei enthält:

gehe zum Quellcode dieser Datei

Funktionen

 create ()
static error (msg)
static memo (msg)
static calcinv (str)
static push_str (str)
static do_move (ob, dest)
 heart_beat ()
static dump_array (ob, indent)
static dump_mapping (ob, indent)
static dump_obj (ob, indent)
static do_recall (arg)
static do_store (arg)
static push (ob)
static pop ()
static top ()
static becomes_obj (argv)
static isSubStr (pl, str, len)
static becomes_pl (argv)
static DumpObj (ob)
static DumpMapp (ob, i)

Variablen

static mixed * stack
static mapping memory
static object * oldinv
static bool mit_namen
static bool fehler_passiert
static bool mit_say
static bool secureinv
static bool dologaccess
static bool pretty
static bool do_profile

Dokumentation der Funktionen

static becomes_obj ( argv   )  [static]

Definiert in Zeile 260 der Datei t_base.c.

Wird benutzt von cmd_inv(), cmd_rekinv(), do_call() und parseNext().

00261 {
00262                 object ob;
00263 
00264                 if( !pointerp(argv) ) // default ist der stack !
00265                                 argv = stack;
00266                 if( !sizeof(argv) )
00267                                 return FALSE; 
00268                 if( stringp(argv[0]) && !catch(call_other(argv[0],"?")) )
00269                 {
00270                   argv[0] = find_object(argv[0]);
00271                                 return TRUE;
00272                 }
00273                 else
00274                                 return objectp(argv[0]);
00275 }

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

static becomes_pl ( argv   )  [static]

Definiert in Zeile 282 der Datei t_base.c.

Benutzt argv und pl.

Wird benutzt von cmd_scan().

00283 {
00284                 object pl;
00285                 object* pllist;
00286                 string str;
00287                 int len;
00288 
00289                 if( !argv ) argv = stack;
00290                 if( !sizeof(argv) || ( becomes_obj() && !interactive(argv[0]) ) )
00291                                 return FALSE;
00292                 if( stringp(argv[0]) )
00293                 {
00294                                 str = lower_case( argv[0] );
00295                                 pl = 0;
00296                                 if( str[<1..<1] == "*" )
00297                                 {               
00298                                                 str = str[0..<2];
00299                                                 len = strlen(str) - 1;
00300                                                 pllist = filter( users(), #'isSubStr, str, len );
00301                                                 if( sizeof(pllist) == 1 )
00302                                                 {
00303                                                                 pl=pllist[0];
00304                                                                 argv[0] = pl;
00305                                                 }
00306                                 }
00307                                 if( !pl && pl=find_player(argv[0]) )
00308                                                 argv[0] = pl;
00309                                 return pl;
00310                 }
00311                 return argv[0];
00312 }

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

static calcinv ( str   )  [static]

Definiert in Zeile 50 der Datei t_base.c.

Benutzt error(), ob(), pop(), push(), top() und TRUE.

Wird benutzt von parseNext().

00051 {
00052                 object ob;
00053                 int val;
00054 
00055                 if( sscanf( str, "%d", val ) == 1 )
00056                 {
00057                                 ob = all_inventory(top());
00058                                 if( val<0 || val>=sizeof(ob) )
00059                                                 return error( "'.': Kein Objekt mit dieser Nummer" );
00060                                 pop();
00061                                 push(ob[val]);
00062                                 return TRUE;
00063                 }
00064 
00065                 if( !(ob=present(str,top())) )
00066                                 return error( "'.': Kein Objekt namens \""+str+"\" gefunden" );
00067                 pop();
00068                 push(ob);
00069                 return TRUE;
00070 }

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

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

create (  ) 

Definiert in Zeile 21 der Datei t_base.c.

Benutzt dologaccess, FALSE, fehler_passiert, memory, mit_namen, mit_say, pretty, secureinv, stack und TRUE.

00022 {
00023                 stack = ({});
00024                 memory = ([]);
00025                 mit_namen = TRUE;
00026                 fehler_passiert = FALSE;
00027                 mit_say = TRUE;
00028                 secureinv = FALSE;
00029                 dologaccess = FALSE;
00030                 pretty = TRUE;
00031 }

static do_move ( ob  ,
dest   
) [static]

Definiert in Zeile 81 der Datei t_base.c.

Benutzt dest(), M_NOCHECK und ob().

00082 {
00083                 int weight;
00084 
00085                 weight = ob->QueryWeight();
00086                 if( environment(ob) )
00087                                 environment(ob)->AddWeight(-weight);
00088                 ob->move(dest,M_NOCHECK);
00089                 dest->AddWeight(weight);
00090 }

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

static do_recall ( arg   )  [static]

Definiert in Zeile 215 der Datei t_base.c.

Wird benutzt von parseNext().

00216 {
00217                 if( member(memory,arg) )
00218                                 push( memory[arg,0] );
00219 }

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

static do_store ( arg   )  [static]

Definiert in Zeile 221 der Datei t_base.c.

Wird benutzt von parseNext().

00222 {
00223                 if ( sizeof(stack) )
00224                 {
00225                                 if( !top() )
00226                                                 memory = efun::m_delete(memory,arg);
00227                                 else
00228                                                 memory += ([ arg: top(); 0 ]);
00229                 }
00230                 else
00231                                 memo( "Es wurde kein Wert in \""+arg+"\" gespeichert" );
00232 }

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

static dump_array ( ob  ,
indent   
) [static]

Definiert in Zeile 133 der Datei t_base.c.

00134 {
00135                 int i;
00136                 for( i=0; i<sizeof(ob); i++ )
00137                 {
00138                                 printf( "%*s", indent, "" );
00139                                 dump_obj( ob[i], indent );
00140                 }
00141 }

static dump_mapping ( ob  ,
indent   
) [static]

Definiert in Zeile 143 der Datei t_base.c.

00144 {
00145                 mixed *index;
00146                 mixed key;
00147                 int i,j,values;
00148 
00149                 index = m_indices( ob );
00150                 values = get_type_info(ob)[1];
00151                 for( i=0; i<sizeof(index); i++ )
00152                 {
00153                                 key = index[i];
00154                                 printf( "%*s", indent, "" );
00155                                 dump_obj( key, indent );
00156                                 for( j=0; j<values; j++ )
00157                                 {
00158                                                 printf( "%*s: ", indent+1, "" );
00159                                                 dump_obj( ob[key,j], indent+3 );
00160                                 }
00161                 }
00162 }

static dump_obj ( ob  ,
indent   
) [static]

Definiert in Zeile 164 der Datei t_base.c.

Wird benutzt von cmd_inv(), cmd_rekinv(), cmd_stack(), cmd_top(), do_call(), do_call_efun(), do_lpc(), do_rinv() und print_memory_line().

00165 {
00166                 if( !pretty )
00167                 {
00168                                 printf( "%O\n", ob );
00169                                 return;
00170                 }
00171                 if( intp(ob) )
00172                                 write( ob + "\n" );
00173                 else if( floatp(ob) )
00174                                 printf( "%1.5f\n", ob );
00175                 else if( stringp(ob) )
00176                 {
00177                                 if ( ob==";" )
00178                                                 write( ";\n" );
00179                                 else
00180                                 {
00181                                                 write( "\"" + implode(old_explode( implode(old_explode( implode(old_explode(
00182                                                                                                                 " "+ob+" ",
00183                                                                                                  "\n"),"\\n"), ESC), "\\e"), "\b"),"\\b")
00184                                                                                                  [1..<2] + "\"\n"
00185                                                 );
00186                                 }
00187                 }
00188                 else if( objectp(ob) )
00189                 {
00190                                 if( mit_namen )
00191                                                 write( object_name(ob)+" ("+ob->name(WER,0)+")\n" );
00192                                 else
00193                                                 write( object_name(ob)+"\n" );
00194                 }
00195                 else if( mappingp(ob) )
00196                 {
00197                                 write( "([\n" );
00198                                 dump_mapping( ob, indent + 2 );
00199                                 printf( "%*s\n", indent + 2, "])" );
00200                 }
00201                 else if( pointerp(ob) )
00202                 {
00203                                 write( "({\n" );
00204                                 dump_array( ob, indent+2 );
00205                                 printf( "%*s\n", indent+2 , "})" );
00206                 }
00207                 else
00208                                 printf( "%O\n", ob );
00209 }

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

static DumpMapp ( ob  ,
i   
) [static]

Definiert in Zeile 343 der Datei t_base.c.

Benutzt DumpObj() und ob().

Wird benutzt von DumpObj().

00344 {
00345   int j,vz;
00346   string ans;
00347 
00348   vz = get_type_info(ob)[1];
00349   ans = DumpObj(m_indices(ob)[i])+":";
00350   for( j=0; j<vz-1; j++ )
00351     ans += DumpObj(ob[m_indices(ob)[i],j])+";";
00352   // rely on value of j
00353   return ans + DumpObj(ob[m_indices(ob)[i],j]);
00354 }

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

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

static DumpObj ( ob   )  [static]

Definiert in Zeile 314 der Datei t_base.c.

Benutzt DumpMapp() und ob().

Wird benutzt von do_lpc() und DumpMapp().

00315 {
00316   string ans;
00317   int i,j;
00318 
00319   if( intp(ob) )
00320     return ""+ob;
00321   else if( stringp(ob) )
00322     return "\""+implode(explode(ob,"\n"),"\\n")+"\"";
00323   else if( objectp(ob) )
00324     return "\""+object_name(ob)+"\"";
00325   else if( mappingp(ob) )
00326   {
00327     ans="([";
00328     for( i=0; i<sizeof(ob)-1; i++ )
00329       ans += DumpMapp(ob,i)+",";
00330     // rely on right value of i
00331     return ans+DumpMapp(ob,i)+"])";
00332   }
00333   else
00334   {
00335     ans="({";
00336     for( i=0; i<sizeof(ob)-1; i++ )
00337       ans += DumpObj(ob[i])+",";
00338     // rely on right value of i
00339     return ans+DumpObj(ob[i])+"})";
00340   }
00341 }

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

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

static error ( msg   )  [static]

Definiert in Zeile 37 der Datei t_base.c.

Benutzt FALSE, fehler_passiert, msg() und TRUE.

Wird benutzt von calcinv().

00038 {
00039                 write( "Fehler in "+msg+".\n" );
00040                 fehler_passiert = TRUE;
00041                 return FALSE;
00042 }

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

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

heart_beat (  ) 

Definiert in Zeile 92 der Datei t_base.c.

Benutzt find_player(), i und owner.

00093 {
00094                 object *newinv;
00095                 object owner;
00096                 int i,j;
00097 
00098                 if( owner=find_player(getuid()) )
00099                 {
00100                                 newinv = sort_array( all_inventory(owner), lambda( ({'a,'b}),
00101                                                 ({ #'<,
00102                                                                 ({ #'object_name, 'a }),
00103                                                                 ({ #'object_name, 'b })
00104                                                 })
00105                                 ) );
00106                                 if( pointerp(oldinv) )
00107                                 {
00108                                                 for( i=0,j=0; i<sizeof(newinv) && j<sizeof(oldinv) ; )
00109                                                 {
00110                                                                 if( newinv[i] == oldinv[j] )
00111                                                                 { i++; j++; }
00112                                                                 else if( object_name(newinv[i]) > object_name(oldinv[j]) )
00113                                                                 {
00114                                                                                 tell_object(owner,
00115                                                                                                 "MEMO: \""+object_name(newinv[i])+"\" entered inventory.\n" );
00116                                                                                 i++;
00117                                                                 }
00118                                                                 else
00119                                                                                 j++;
00120                                                 }
00121                                                 for( ; i<sizeof(newinv) ; i++ )
00122                                                                 tell_object( owner,
00123                                                                                 "MEMO: \""+object_name(newinv[i])+"\" entered inventory.\n" );
00124                                 }
00125                 }
00126                 oldinv = newinv;
00127 }

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

static isSubStr ( pl  ,
str  ,
len   
) [static]

Definiert in Zeile 277 der Datei t_base.c.

00278 {
00279                 return getuid(pl)[0..len] == str;
00280 }

static memo ( msg   )  [static]

Definiert in Zeile 44 der Datei t_base.c.

Benutzt FALSE und msg().

Wird benutzt von cmd_memory(), cmd_stack() und parseNext().

00045 {
00046                 write( "MEMO: "+msg+".\n" );
00047                 return FALSE;
00048 }

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

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

static pop (  )  [static]

Definiert in Zeile 243 der Datei t_base.c.

00244 {
00245                 mixed answer;
00246 
00247                 if( !sizeof( stack ) )
00248                                 return FALSE;
00249                 answer = stack[0];
00250                 stack = stack[1..];
00251                 return answer;
00252 }

static push ( ob   )  [static]

Definiert in Zeile 238 der Datei t_base.c.

00239 {
00240                 stack = ({ ob }) + stack;
00241 }

static push_str ( str   )  [static]

Definiert in Zeile 72 der Datei t_base.c.

Benutzt ESC, old_explode() und push().

Wird benutzt von parseNext().

00073 {
00074                 return
00075                                 push( implode(old_explode( implode(old_explode( implode(old_explode(
00076                                                                                 " "+str+" ",
00077                                                                 "\\n"),"\n"), "\\e"),ESC), "\\b"),"\b")
00078                                 [1..<2] );
00079 }

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

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

static top (  )  [static]

Definiert in Zeile 254 der Datei t_base.c.

Wird benutzt von calcinv(), cmd_dup(), cmd_inv(), cmd_rekinv(), cmd_scan(), cmd_top() und parseNext().

00255 {
00256                 if( sizeof(stack) )
00257                                 return stack[0];
00258 }

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

Variablen-Dokumentation

bool do_profile [static]

Definiert in Zeile 19 der Datei t_base.c.

Wird benutzt von _query_autoloadobj(), _set_autoloadobj() und long().

bool dologaccess [static]

Definiert in Zeile 17 der Datei t_base.c.

Wird benutzt von _query_autoloadobj(), _set_autoloadobj(), create(), logaccess() und long().

bool fehler_passiert [static]

Definiert in Zeile 14 der Datei t_base.c.

Wird benutzt von create(), do_cmd(), error() und parse().

mapping memory [static]

Definiert in Zeile 11 der Datei t_base.c.

Wird benutzt von create().

bool mit_namen [static]

Definiert in Zeile 13 der Datei t_base.c.

Wird benutzt von _query_autoloadobj(), _set_autoloadobj(), create() und long().

bool mit_say [static]

Definiert in Zeile 15 der Datei t_base.c.

Wird benutzt von _query_autoloadobj(), _set_autoloadobj(), create(), long() und parse().

object* oldinv [static]

Definiert in Zeile 12 der Datei t_base.c.

bool pretty [static]

Definiert in Zeile 18 der Datei t_base.c.

Wird benutzt von _query_autoloadobj(), _set_autoloadobj(), create() und long().

bool secureinv [static]

Definiert in Zeile 16 der Datei t_base.c.

Wird benutzt von _query_autoloadobj(), _set_autoloadobj(), create(), logaccess() und long().

mixed* stack [static]

Definiert in Zeile 10 der Datei t_base.c.

Erzeugt am Thu Jun 3 14:40:23 2010 für MorgenGrauen Mudlib von  doxygen 1.6.3