upd.c-Dateireferenz

#include <magier.h>
#include <player.h>
#include <debug_info.h>
#include <wizlevels.h>
#include <moving.h>
#include <properties.h>
#include <logging.h>

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

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	NEED_PROTOTYPES
Funktionen
static varargs int	_make (string file, int flags, int recursive)
static mixed *	_query_localcmds ()
static mixed	_save (object obj, object inv_saver)
private object	_reload (string file, int clone, int flags, string err)
private varargs int	_update (string file, int dummy, int flags)
private void	_instance_upd (string file, int flags, mixed obj, int instances, int firstcall)
varargs private int	_do_make (string file, int clone, int flags, string dep, string ready)
private string	_make_dep (mixed dep, string prefix)
private int	_illegal_closure (mixed arg)
static int	_upd (string cmdline)
static int	_load (string cmdline)

Makro-Dokumentation

#define NEED_PROTOTYPES

Definiert in Zeile 12 der Datei upd.c.

Dokumentation der Funktionen

varargs private int _do_make	(	string	file,
		int	clone,
		int	flags,
		string *	dep,
		string *	ready
	)

Definiert in Zeile 203 der Datei upd.c.

Benutzt _make(), _reload(), err, file_time(), UPD_I, UPD_M und UPD_V.

Wird benutzt von _make().

00205 {
00206   object obj;
00207   string *ilist, err, *down;
00208   int ret;
00209   
00210   if (!pointerp(ready)) ready = ({});
00211   ready += ({ file });
00212   
00213   if ( !(obj = _reload(file,clone,flags,&err)))
00214   {
00215     dep += ({ err });
00216     return 0;
00217   }
00218   
00219   ilist = inherit_list(obj)-ready;
00220   
00221   down = ({});
00222   
00223   while (sizeof(ilist))
00224   {
00225     ret = _do_make( ilist[0],0,flags, &down, &ready )||ret;
00226     ilist[0..0] = ({});
00227     ilist -= ready;
00228   }
00229   
00230   if ( ret||file_time(file)>program_time(obj)||(flags &UPD_I))
00231     if ( _make( file, flags & ~(UPD_M|UPD_I) ,1) < 0 ) 
00232       dep = ({ "{" + explode(file,"/")[<1] + "}", down });
00233     else{
00234       dep = ({ "[" + explode(file,"/")[<1] + "]", down });
00235       ret = 1;
00236     }
00237   else if (flags&UPD_V) dep += ({ explode(file,"/")[<1], down });
00238   return ret;
00239 }

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

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

private int _illegal_closure ( mixed arg )

Definiert in Zeile 272 der Datei upd.c.

Benutzt i und query_closure_object().

Wird benutzt von _make().

00273 {
00274   int i, j;
00275   string *indices;
00276   
00277   if ( closurep(arg) && !objectp(query_closure_object(arg)) )
00278     return 1;
00279   
00280   if ( pointerp(arg) ){
00281     for ( i = sizeof(arg); i--; )
00282       if ( _illegal_closure(arg[i]) )
00283         return 1;
00284   }
00285   else if ( mappingp(arg) ){
00286     indices = m_indices(arg);
00287     for ( i = sizeof(indices); i--; )
00288       for ( j = get_type_info( arg, 1 ); j--; )
00289         if ( _illegal_closure(arg[indices[i], j]) )
00290           return 1;
00291   }
00292   return 0;
00293 }

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

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

private void _instance_upd	(	string	file,
		int	flags,
		mixed	obj,
		int	instances,
		int	firstcall
	)

Definiert in Zeile 162 der Datei upd.c.

Benutzt _make(), call_out(), i, UPD_A, UPD_F und UPD_S.

00164 {
00165  int i;
00166  if (firstcall)
00167     printf("upd: %s: %s Instanzen.\n",file,flags&UPD_A?"Aktualisiere":"Suche");
00168   
00169   while (get_eval_cost()>220000 && i < sizeof(obj))
00170   {
00171     if (!objectp(obj[i]))
00172       instances--;
00173     else
00174     {
00175       if (flags&UPD_F&&!(flags&UPD_S))
00176         printf( "upd: %O gefunden in %s\n", obj[i],
00177                 environment(obj[i])?object_name(environment(obj[i])) 
00178                 : "keiner Umgebung" );
00179       if (flags&UPD_A) _make(object_name(obj[i]), flags & ~(UPD_A|UPD_F),1 );
00180     }
00181     i++;
00182   }
00183   if (i < sizeof(obj)) 
00184     call_out( #'_instance_upd/*'*/,2,file,flags,obj[i..],instances,0);
00185   else
00186     printf( "upd: %s: %d Instanzen %s\n", file, instances,
00187             (flags & UPD_A) ? "aktualisiert" : "gefunden" );
00188   return;
00189 }

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

static int _load ( string cmdline ) [static]

Definiert in Zeile 495 der Datei upd.c.

00496 {
00497   int flags;
00498   mixed *args;
00499 
00500   cmdline=_unparsed_args();
00501   args=parseargs(cmdline,&flags,"",1);
00502   if(flags==-1||!sizeof(args))
00503     return USAGE("load <datei> [<datei> ..]");
00504   args=file_list(args,MODE_UPD,0,"/");
00505   if(!sizeof(args)) return printf("load: Keine passende Datei gefunden!\n"),1;
00506   args=map(args,(: (($1[FILESIZE]!=-2||find_object($1[FULLNAME]))?
00507                           $1[FULLNAME]:0) :))-({0});
00508 
00509   if(!sizeof(args))
00510     return printf("load: Verzeichnisse koennen nicht geladen werden!\n"),1;
00511   asynchron(args,#'_make,UPD_LOAD,0,0);
00512   return 1;
00513 }

static varargs int _make	(	string	file,
		int	flags,
		int	recursive
	)			`[static]`

Definiert in Zeile 301 der Datei upd.c.

Benutzt _do_make(), _illegal_closure(), _make_dep(), _reload(), _update(), call_out(), env(), err, F_QUERY_METHOD, F_SET_METHOD, F_VALUE, i, inv(), INV_SAVE, items, m_delete(), msg(), NO_CHECK, P_ITEMS, RET_FAIL, RET_OK, UPD_A, UPD_C, UPD_D, UPD_F, UPD_I, UPD_L, UPD_LOAD, UPD_M, UPD_R und UPD_S.

Wird benutzt von _do_make() und _instance_upd().

00303 00304 00305 00306   mixed tmp; 00307 00308 00309 00310 00311 00312 00313 00314 00315 00316 00317 00318 00319 00320 00321 00322 00323   { 00324 00325 00326 00327 00328 00329 00330 00331 00332 00333 00334 00335 00336 00337 00338 00339   } 00340 00341 00342 00343 00344 00345 00346 00347   { 00348 00349 00350 00351 00352   } 00353 00354 00355 00356 00357 00358   { 00359 00360 00361 00362 00363 00364 00365     { 00366 00367       { 00368 00369 00370 00371 00372 00373 00374 00375 00376 00377 00378 00379 00380 00381 00382 00383 00384       } 00385 00386 00387 00388 00389     } 00390 00391 00392 00393 00394     { 00395 00396 00397 00398 00399     } 00400 00401 00402 00403 00404 00405 00406 00407 00408     { 00409 00410 00411 00412 00413 00414       { 00415 00416 00417 00418         { 00419 00420 00421 00422 00423 00424 00425 00426 00427 00428 00429 00430 00431 00432 00433 00434         } 00435 00436 00437 00438 00439 00440 00441 00442 00443 00444         { 00445 00446 00447         } 00448       } 00449 00450 00451     } 00452   } 00453 00454 00455 00456 00457 00458 00459 00460 00461 00462 00463 00464 }

class="fragment">00302 { string msg, err, blue; int inst; object obj, inv_saver; msg = ""; if (!file) return printf( "upd: Kein Filename uebergeben!\n" ), RET_FAIL; // Filename in Blue, Objektname in blue, Instanznummer in inst if (sscanf(file,"%s#%d",blue,inst)==2) blue += ".c"; else blue = file + (file[<2..]==".c" ? "" : ".c"); // Alle Instanzen durchsuchen im Falle von -a oder -f if ((flags & UPD_LOAD)&&find_object(file)) return printf("load: %s: Objekt ist schon geladen.\n",file),RET_OK; if ( flags & (UPD_F|UPD_A)) if (inst) return printf( "upd: %s: Eine Instanz kann keine " + "Clones haben.\n",file ), RET_FAIL; if ((tmp=_update(file, 1,flags))==-1) return printf( "upd: %s: Kein Vollzugriff auf die " + "Datei erlaubt.\n",file), RET_FAIL; if (tmp==0) return RET_FAIL; tmp=clones(blue[0..<3],2); if (sizeof(tmp)) call_out( #'_instance_upd/*'*/, 0, file,flags,tmp,sizeof(tmp),1); else printf( "upd: %s: Keine Clones vorhanden!\n", blue[0..<3]); if ( (flags & UPD_F) && !(flags &(UPD_R|UPD_L|UPD_LOAD))) return RET_OK; // Nichts laden -> Auch kein Backup // Backupraum festlegen if( blue==INV_SAVE ) { printf("upd: Achtung: Raum zum Zwischenspeichern soll geladen werden?!\n"); } if ( !(inv_saver=load_object(INV_SAVE)) ) printf("upd: %s: Raum zum Zwischenspeichern des " + "Rauminhalts ist nicht ladbar.\n" + " %s\n",file,INV_SAVE); return RET_FAIL; // Wenn das Objekt existiert bzw. Deep aktualisiert werden soll if ( (!(flags&UPD_LOAD))&& ((obj = find_object(file)) || (flags & (UPD_M|UPD_I)))) object *inv, env, *pl_inv; mapping pro; int i; // Wenn Objekt existiert, dann Inhalt sichern: if (obj) if (!(flags&UPD_D)&&(flags&(UPD_L|UPD_R))) if (i=sizeof(inv=(all_inventory(obj)-({0})))) { mixed items; // Herausbekommen, ob hier Items existieren, die per AddItem // erzeugt werden. Die duerfen nicht gesichert werden. items=(mixed)obj->QueryProp(P_ITEMS); // mixed, da array of arrays if (pointerp(items)&&sizeof(items)) { items=transpose_array(items)[0]; while (i--) if (member(items, inv[i])==-1) inv[i]->move(inv_saver,NO_CHECK); } else // In diesem Objekt sind keine Items gesetzt. while (i--) inv[i]->move(inv_saver,NO_CHECK); } else inv=map( deep_inventory(obj), #'_save/*'*/, inv_saver )-({0}); env = environment(obj); if ( flags & UPD_C ) pro = (mapping)(obj->QueryProperties()); else inv = ({}); // Ererbte Objekte durchsuchen. if ( flags & (UPD_M|UPD_I) ) string *dep; dep = ({}); _do_make( blue, inst, flags & ~(UPD_M|UPD_L|UPD_R|UPD_F|UPD_A), &dep ); printf( _make_dep( dep, "" ) + "\n" ); // Tatsaechlichen Update durchfuehren if ( _update(file, 0, flags)< 0) return RET_FAIL; msg += (inst ? "zerstoert" : "aktualisiert"); // Neu laden ?? if ( flags & (UPD_R|UPD_L) ) if ( obj = _reload( blue,inst,flags, &err ) ) msg += ", " + (inst ? "neu geclont" : "neu geladen"); // Neu geladen: Properties wiederherstellen, Closures filtern if (!err) if (!obj) obj = find_object(file); if ( pro && (flags & UPD_C) ) string *names; names = m_indices(pro); // Closures in (mittlerweile) zerstoerten Objekten // rausfiltern, damit die (hoffentlich korrekten) Closures // im neu geclonten Objekt erhalten bleiben for ( i = sizeof(names); i--; ) if ( _illegal_closure(pro[names[i], F_VALUE]) || _illegal_closure(pro[names[i], F_QUERY_METHOD]) || _illegal_closure(pro[names[i], F_SET_METHOD]) ) efun::m_delete( pro, names[i] ); obj->SetProperties(pro); msg += ", Properties gesetzt"; if (env) if ( obj->move( env, NO_CHECK ) <= 0 ) printf( "upd: /%O konnte nicht in /%O zurueckbewegt werden\n", obj, env ); else msg += ", bewegt"; if (i=sizeof(inv)) while(i--) if (inv[i]) inv[i]->move(obj, NO_CHECK ); msg += ", Inhalt zurueckbewegt"; else return printf( "upd: %s: %s", file, err ), RET_FAIL; else if ( !_update(file, 0, flags) && (flags & (UPD_L|UPD_LOAD)) ) if ( !_reload( blue, inst, flags, &err ) ) return printf( "%s: %s: %s", (flags&UPD_LOAD?"load":"upd"),file, err ), RET_FAIL; else msg += "geladen"; if ( strlen(msg)&&!(flags&UPD_S&&recursive) ) printf("%s: %s: %s.\n",(flags&UPD_LOAD?"load":"upd"),file,msg); return RET_OK;

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

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

private string _make_dep	(	mixed	dep,
		string	prefix
	)

Definiert in Zeile 249 der Datei upd.c.

Benutzt i.

Wird benutzt von _make().

00250 {
00251   string ret;
00252   int i, size;
00253   
00254   ret="";
00255   size=sizeof(dep);
00256   for (i=0; i<size;i++)
00257     if (pointerp(dep[i]))
00258       ret += _make_dep(dep[i],prefix + (i < (size-1) ? "| ":" "));
00259     else 
00260       ret += prefix + "+-" + dep[i] + "\n";
00261   return ret;
00262 }

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

static mixed* _query_localcmds ( ) [static]

Definiert in Zeile 25 der Datei upd.c.

Benutzt LEARNER_LVL.

00026 {
00027   return ({({"upd","_upd",0,LEARNER_LVL}),
00028            ({"update","_upd",0,LEARNER_LVL}),
00029            ({"Update","_upd",0,LEARNER_LVL}),
00030            ({"load","_load",0,LEARNER_LVL})});
00031 }

private object _reload	(	string	file,
		int	clone,
		int	flags,
		string	err
	)

Definiert in Zeile 64 der Datei upd.c.

Benutzt UPD_B.

Wird benutzt von _do_make() und _make().

00065 {
00066   object obj;
00067   
00068   if (!obj=find_object(file[0..<3]+(clone?("#"+clone):"")))
00069   {
00070     int pos,pos2;
00071     string bt;
00072 
00073     if(file_size(file)<0)
00074     {
00075       if (file_size(file)==-1)
00076         err = sprintf("upd: %s: Datei existiert nicht.\n", file);
00077       else // directory
00078         err = sprintf("upd: %s: Verzeichnisse koennen nicht geladen "
00079                       "werden.\n",file);
00080       return obj; // 0
00081     }
00082     pos = max(file_size(__DEBUG_LOG__),0);
00083 
00084     if ((err = (clone?catch(obj = clone_object(file)):
00085                 catch(load_object(file)) )) && (flags & UPD_B)) 
00086     {     
00087       if (( pos2=file_size(__DEBUG_LOG__)) > pos )
00088         err+=sprintf("\nBacktrace:\n%s",
00089                      read_bytes(__DEBUG_LOG__,pos, pos2-pos ));
00090       else
00091         err+=sprintf("\nKEIN BACKTRACE VERFUEGBAR!\n");
00092     }
00093     if (!err&&!obj&&(!obj = find_object(file[0..<3])))
00094       err += sprintf( "upd: %s: Blueprint nach dem Laden zerstoert.\n",file );
00095   }
00096   else
00097     err=sprintf("upd: Objekt existiert schon: %O\n",obj);
00098   return obj;
00099 }

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

static mixed _save	(	object	obj,
		object	inv_saver
	)			`[static]`

Definiert in Zeile 41 der Datei upd.c.

Benutzt NO_CHECK.

00042 { 
00043     if ( query_once_interactive(obj) )
00044       { 
00045         obj->move( inv_saver, NO_CHECK );
00046         return obj;
00047       }
00048     return 0;
00049 }

static int _upd ( string cmdline ) [static]

Definiert in Zeile 470 der Datei upd.c.

Benutzt _unparsed_args(), asynchron(), file_list(), flags, FULLNAME, MODE_UPD, parseargs(), UPD_H, UPD_OPTS und USAGE.

00471 {
00472   int flags;
00473   mixed *args;
00474 
00475   cmdline=_unparsed_args();
00476   args=parseargs(cmdline,&flags,UPD_OPTS,1);
00477   if(flags==-1||!sizeof(args))
00478     return USAGE("upd [-"+UPD_OPTS+"] <datei> [<datei> ..]");
00479   args=file_list(args,MODE_UPD,0,"/");
00480   if(!sizeof(args)) return printf("upd: Keine passende Datei gefunden!\n"),1;
00481 
00482   args=map(args,(: $1[FULLNAME] :))-({0});
00483   
00484   if(!sizeof(args))
00485     return printf("upd: Verzeichnisse koennen nicht aktualisiert werden!\n"),1;
00486   if (query_verb()=="Update") flags|=UPD_H;
00487   asynchron(args,#'_make,flags,0,0);
00488   return 1;
00489 }

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

private varargs int _update	(	string	file,
		int	dummy,
		int	flags
	)

Definiert in Zeile 112 der Datei upd.c.

Benutzt destruct(), err, inv(), IS_ARCH, MAY_READ, MAY_WRITE, ob(), UPD_D und UPD_H.

Wird benutzt von _make().

00113 {
00114   object obj;
00115   string err;
00116   if (!dummy&&!objectp(obj = find_object(file))) return 0;
00117   if (!IS_ARCH(this_object()))
00118   {
00119     if(!MAY_WRITE(file))
00120       return (printf("upd:�%s: Keine Schreibrechte!\n",file), -1);
00121     if(!MAY_READ(file)) 
00122       return (printf("upd: %s: Keine Leserechte!\n", file), -1);
00123   }
00124   if (dummy) return 1;
00125   
00126   if ( flags & UPD_D )
00127   {
00128     object *inv;
00129     if (sizeof(inv = deep_inventory(obj)))
00130     {
00131       printf("upd: %s: Entferne Objekte im Inventar\n", file );
00132       if (!(flags&UPD_H))
00133       {
00134         if(err=catch(filter_objects( inv, "remove", 1 )))
00135           printf("upd: %s: Fehlgeschlagen. Grund:\n%s\n",
00136                  file,err);
00137       }
00138       if (sizeof(inv = deep_inventory(obj)))
00139                 filter(inv, function void (object ob)
00140                     {destruct(ob);});
00141     }
00142   }
00143   if (!(flags&UPD_H))
00144   {
00145     if(err = catch(obj->remove()))
00146       printf("upd: %s: remove() fehlgeschlagen. Aufruf von " +
00147              "destruct().\n",file);
00148   }
00149   if(objectp(obj)) destruct(obj);
00150   return 1;
00151 }

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

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

upd.c-Dateireferenz

Makrodefinitionen

Funktionen

Makro-Dokumentation

Dokumentation der Funktionen