BOOL PEXPORT Kpp_DeleteFunc(FUNCID idFunc) { LPFUNC lpFunc = (LPFUNC) KppGetItem(FUNC, idFunc); if (!lpFunc) return ERROR; if (FLAGS(lpFunc) & ITEMOPEN) return KppRegisterKappaMessage(hResThisDll, IDE_BEINGEDITED, lpIDs->idError, NAME(lpFunc), NULLID); /* Check for system defined function */ if (FLAGS(lpFunc) & UNDELETABLE) { KppReleaseItem(FUNC, idFunc); return KppRegisterKappaMessage(hResThisDll, IDE_NOSYSDELETE, lpIDs->idError, NAME(lpFunc), NULLID); } /* first clear up the function */ Kpp__ResetFunc(lpFunc); /* then delete the func itself */ KppReleaseItem(FUNC, idFunc); KppDeleteItem(FUNC, idFunc); /* Add to KnowledgeTools */ KppAddItemCB(FUNC, -1); return TRUE; }
RULEID __CopyRule(LPRULE lpOldRule, ITEMID idName) { #ifdef INFERENCE RULEID idRule; LPRULE lpRule; LPEXP lpBody; EXPID idBody; if (GetRule(idName) != NULLID) return NULLID; idRule = KppAddItemAndName (RULE, (LPLPSTR)&lpRule, idName); if (!idRule) return NULLID; NAME(lpRule) = idName; FLAGS(lpRule) = NULL; PRIORITY(lpRule) = 0; MATCHES(lpRule) = NULLID; NUMVARS(lpRule) = NUMVARS(lpOldRule); if (! (FLAGS(lpRule) & CBODY)) { VARS(lpRule) = KppDeepListCopy(VARS(lpOldRule), Kpp__CopyVar,idRule); idBody = BODY(lpRule) = KppCopyExp( BODY(lpOldRule), (LPLPSTR)&lpBody, kPERMMODE); KppReleaseExp(idBody); } KppReleaseItem(RULE, idRule); /* Add to KnowledgeTools */ KppAddItemCB (RULE, 1); return idRule; #endif }
bool can_see(dbref player, dbref thing, bool can_see_loc) { if (!OkObj(player) || !OkObj(thing)) return 0; if (player == thing || Typeof(thing) == TYPE_EXIT || Typeof(thing) == TYPE_ROOM) return 0; if (Light(thing)) return 1; if (can_see_loc) { switch (Typeof(thing)) { case TYPE_PROGRAM: return ((FLAGS(thing) & LINK_OK) || controls(player, thing) || (POWERS(player) & POW_SEE_ALL)); case TYPE_PLAYER: if (tp_dark_sleepers) { return (!Dark(thing) || online(thing) || (POWERS(player) & POW_SEE_ALL)); } default: return (!Dark(thing) || (POWERS(player) & POW_SEE_ALL) || (controls(player, thing) && !(FLAGS(player) & STICKY))); } } else { /* can't see loc */ return (controls(player, thing) && !(FLAGS(player) & STICKY)); } }
BOOL PEXPORT Kpp_DeleteGoal(GOALID idGoal) { #ifdef INFERENCE ATOMID idName; LPGOAL lpGoal; if ((lpGoal = (LPGOAL) KppGetItem(GOAL, idGoal)) == NULL) return ERROR; if (FLAGS (lpGoal) & ITEMOPEN) return KppRegisterKappaMessage (hResThisDll, IDE_BEINGEDITED, lpIDs->idError, NAME(lpGoal), NULLID); /* Check for system defined goal */ if (FLAGS(lpGoal) & UNDELETABLE) { idName = NAME (lpGoal); KppReleaseItem(GOAL, idGoal); return KppRegisterKappaMessage (hResThisDll, IDE_NOSYSDELETE,lpIDs->idError, idName, NULLID); } /* if */ /* reset the goal contents */ Kpp__ResetGoal(lpGoal); /* then delete the goal itself */ KppReleaseItem(GOAL, idGoal); KppDeleteItem(GOAL, idGoal); /* Add to KnowledgeTools */ KppAddItemCB (GOAL, -1); #endif return TRUE; }
/*** SetMarkFile - Change markfile * * Purpose: * * Changes to a new markfile. * * Input: * val - String after the 'markfile' switch * * Output: * * Returns Error string if error, NULL otherwise * * Notes: * * We: * * UNDONE:o Magically ensure that the current markfile is up to date and * saved to disk. This means, at the very least, that there * can be no dirty files. * * o Remove the current markfile from the file list. * * o Read in the new markfile. * * o Invalidate all current marks. This is just marking them * invalid in the PFILE. * * *************************************************************************/ char * SetMarkFile ( char *val ) { REGISTER PFILE pFile; buffer tmpval; pathbuf pathname; strcpy ((char *) tmpval, val); if (NULL == CanonFilename (tmpval, pathname)) { sprintf (buf, "'%s': name is malformed", tmpval); return buf; } if (!(pFile = FileNameToHandle (pathname, NULL))) { pFile = AddFile (pathname); } if (!TESTFLAG(FLAGS(pFile), REAL) && !FileRead (pathname, pFile, FALSE)) { RemoveFile (pFile); sprintf (buf, "'%s' - %s", pathname, error()); return buf; } pFileMark = pFile; for (pFile = pFileHead; pFile; pFile = pFile->pFileNext) { if (!TESTFLAG(FLAGS(pFile), FAKE)) { RSETFLAG (FLAGS(pFile), VALMARKS); } } return NULL; }
int opt_default(const char *opt, const char *arg) { const AVOption *oc, *of, *os; char opt_stripped[128]; const char *p; const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class(), *sc; if (!(p = strchr(opt, ':'))) p = opt + strlen(opt); av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1)); if ((oc = av_opt_find(&cc, opt_stripped, NULL, 0, AV_OPT_SEARCH_CHILDREN|AV_OPT_SEARCH_FAKE_OBJ)) || ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') && (oc = av_opt_find(&cc, opt+1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ)))) av_dict_set(&codec_opts, opt, arg, FLAGS(oc)); if ((of = av_opt_find(&fc, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) av_dict_set(&format_opts, opt, arg, FLAGS(of)); #if CONFIG_SWSCALE sc = sws_get_class(); if ((os = av_opt_find(&sc, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) { // XXX we only support sws_flags, not arbitrary sws options int ret = av_set_string3(sws_opts, opt, arg, 1, NULL); if (ret < 0) { av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt); return ret; } } #endif if (oc || of || os) return 0; av_log(NULL, AV_LOG_ERROR, "Unrecognized option '%s'\n", opt); return AVERROR_OPTION_NOT_FOUND; }
void skipproperties(FILE * f, dbref obj) { char buf[BUFFER_LEN * 3]; int islisten = 0; /* get rid of first line */ fgets(buf, sizeof(buf), f); fgets(buf, sizeof(buf), f); while (strcmp(buf, "*End*\n")) { if (!islisten) { if (string_prefix(buf, "_listen")) islisten = 1; if (string_prefix(buf, "~listen")) islisten = 1; if (string_prefix(buf, "~olisten")) islisten = 1; } fgets(buf, sizeof(buf), f); } if (islisten) { FLAGS(obj) |= LISTENER; } else { FLAGS(obj) &= ~LISTENER; } }
const char * unparse_object(dbref player, dbref loc) { static char buf[BUFFER_LEN]; if (player == NOTHING) goto islog; if (Typeof(player) != TYPE_PLAYER) player = OWNER(player); islog: switch (loc) { case NOTHING: return "*NOTHING*"; case AMBIGUOUS: return "*AMBIGUOUS*"; case HOME: return "*HOME*"; default: if (loc < 0 || loc >= db_top) return "*INVALID*"; if ((player == NOTHING) || (!(FLAGS(player) & STICKY) && (can_link_to(player, NOTYPE, loc) || ((Typeof(loc) != TYPE_PLAYER) && (controls_link(player, loc) || (FLAGS(loc) & CHOWN_OK)))))) { /* show everything */ snprintf(buf, sizeof(buf), "%.*s(#%d%s)", (BUFFER_LEN / 2), NAME(loc), loc, unparse_flags(loc)); return buf; } else { /* show only the name */ return NAME(loc); } } }
BOOL PEXPORT Kpp_DeleteRule(RULEID idRule) { #ifdef INFERENCE ATOMID idName; LPRULE lpRule; if ((lpRule = (LPRULE) KppGetItem(RULE, idRule)) == NULL) return ERROR; if (FLAGS (lpRule) & ITEMOPEN) return KppRegisterKappaMessage (hResThisDll, IDE_BEINGEDITED, lpIDs->idError, NAME(lpRule), NULLID); /* Check for system defined rule */ if (FLAGS(lpRule) & UNDELETABLE) { idName = NAME (lpRule); KppReleaseItem(RULE, idRule); return KppRegisterKappaMessage (hResThisDll, IDE_NOSYSDELETE,lpIDs->idError, idName, NULLID); } /* if */ /* first clear up the rule */ Kpp__ResetRule(lpRule); /* finally delete the rule itself */ KppReleaseItem(RULE, idRule); KppDeleteItem(RULE, idRule); /* Add to KnowledgeTools */ KppAddItemCB (RULE, -1); KppChangeRuleCB (); #endif return TRUE; }
/* Use this to create a program. First, find a program that matches that name. If there's one, then we put him into edit mode and do it. Otherwise, we create a new object for him, and call it a program. */ void do_prog(int descr, dbref player, const char *name) { dbref i; struct match_data md; if (Typeof(player) != TYPE_PLAYER) { anotify_nolisten2(player, CFAIL "Only players can edit programs."); return; } else if (!Mucker(player)) { anotify_nolisten2(player, CFAIL NOMBIT_MESG); return; } else if (!tp_building || tp_db_readonly) { anotify_nolisten2(player, CFAIL NOBUILD_MESG); return; } else if (!*name) { anotify_nolisten2(player, CINFO "No program name given."); return; } init_match(descr, player, name, TYPE_PROGRAM, &md); match_possession(&md); match_neighbor(&md); match_registered(&md); match_absolute(&md); if ((i = match_result(&md)) == NOTHING) { i = new_program(OWNER(player), name); FLAGS(i) |= INTERNAL; DBFETCH(player)->sp.player.curr_prog = i; anotify_fmt(player, CSUCC "Program %s created with number %d.", name, i); anotify_nolisten2(player, CINFO "Entering editor."); } else if (i == AMBIGUOUS) { anotify_nolisten2(player, CINFO "I don't know which one you mean!"); return; } else { if ((Typeof(i) != TYPE_PROGRAM) || !controls(player, i)) { anotify_fmt(player, CFAIL "%s", tp_noperm_mesg); return; } else if (FLAGS(i) & INTERNAL) { anotify_nolisten2(player, CFAIL NOEDIT_MESG); return; } DBFETCH(i)->sp.program.first = read_program(i); FLAGS(i) |= INTERNAL; DBFETCH(player)->sp.player.curr_prog = i; anotify_fmt(player, CINFO "Entering editor for %s.", unparse_object(player, i)); /* list current line */ do_list(player, i, 0, 0, 0); DBDIRTY(i); } FLAGS(player) |= INTERACTIVE; DBDIRTY(player); }
/* * could_doit: Checks to see if player could actually do what is proposing * to be done: if thing is an exit, this checks to see if the exit will * perform a move that is allowed. Then, it checks the @lock on the thing, * whether it's an exit or not. */ int could_doit(int descr, dbref player, dbref thing) { dbref source, dest, owner; if (Typeof(thing) == TYPE_EXIT) { /* If exit is unlinked, can't do it. */ if (DBFETCH(thing)->sp.exit.ndest == 0) { return 0; } owner = OWNER(thing); source = DBFETCH(player)->location; dest = *(DBFETCH(thing)->sp.exit.dest); if (Typeof(dest) == TYPE_PLAYER) { /* Check for additional restrictions related to player dests */ dbref destplayer = dest; dest = DBFETCH(dest)->location; /* If the dest player isn't JUMP_OK, or if the dest player's loc * is set BOUND, can't do it. */ if (!(FLAGS(destplayer) & JUMP_OK) || (FLAGS(dest) & BUILDER)) { return 0; } } /* for actions */ if ((DBFETCH(thing)->location != NOTHING) && (Typeof(DBFETCH(thing)->location) != TYPE_ROOM)) { /* If this is an exit on a Thing or a Player... */ /* If the destination is a room or player, and the current * location is set BOUND (note: if the player is in a vehicle * set BUILDER this will also return failure) */ if ((Typeof(dest) == TYPE_ROOM || Typeof(dest) == TYPE_PLAYER) && (FLAGS(source) & BUILDER)) return 0; /* If secure_teleport is true, and if the destination is a room */ if (tp_secure_teleport && Typeof(dest) == TYPE_ROOM) { /* if player doesn't control the source and the source isn't * set Jump_OK, then if the destination isn't HOME, * can't do it. (Should this include getlink(owner)? Not * everyone knows that 'home' or '#-3' can be linked to and * be treated specially. -winged) */ if ((dest != HOME) && (!controls(owner, source)) && ((FLAGS(source) & JUMP_OK) == 0)) { return 0; } /* FIXME: Add support for in-server banishment from rooms * and environments here. */ } } } /* Check the @lock on the thing, as a final test. */ return (eval_boolexp(descr, player, GETLOCK(thing), thing)); }
const char * mfn_force(MFUNARGS) { char *nxt, *ptr; dbref obj = mesg_dbref_raw(player, what, perms, argv[0]); if (obj == AMBIGUOUS || obj == UNKNOWN || obj == NOTHING || obj == HOME) ABORT_MPI("FORCE","Failed match. (arg1)"); if (obj == PERMDENIED) ABORT_MPI("FORCE","Permission denied. (arg1)"); if (Typeof(obj) != TYPE_THING && Typeof(obj) != TYPE_PLAYER) ABORT_MPI("FORCE","Bad object reference. (arg1)"); if (!*argv[1]) ABORT_MPI("FORCE","Null command string. (arg2)"); if (!tp_zombies && !Wizperms(perms)) ABORT_MPI("FORCE","Permission Denied."); if (!Wizperms(perms)) { const char *ptr = RNAME(obj); char objname[BUFFER_LEN], *ptr2; dbref loc = getloc(obj); if (Typeof(obj) == TYPE_THING) { if (FLAGS(obj) & DARK) ABORT_MPI("FORCE","Cannot force a dark puppet."); if ((FLAGS(OWNER(obj)) & ZOMBIE)) ABORT_MPI("FORCE","Permission denied."); if (loc != NOTHING && (FLAGS(loc) & ZOMBIE) && Typeof(loc) == TYPE_ROOM) ABORT_MPI("FORCE","Cannot force a Puppet in a no-puppets room."); for (ptr2 = objname; *ptr && !isspace(*ptr);) *(ptr2++) = *(ptr++); *ptr2 = '\0'; if (lookup_player(objname) != NOTHING) ABORT_MPI("FORCE","Cannot force a thing named after a player."); } if (!(FLAGS(obj) & XFORCIBLE)) { ABORT_MPI("FORCE","Permission denied: forced object not @set Xforcible."); } if (!test_lock_false_default(perms, obj, "@/flk")) { ABORT_MPI("FORCE","Permission denied: Object not force-locked to trigger."); } } if (God(obj)) ABORT_MPI("FORCE","Permission denied: You can't force God."); if (force_level) ABORT_MPI("FORCE","Permission denied: You can't force recursively."); strcpy(buf, argv[1]); ptr = buf; do { nxt = index(ptr, '\r'); if (nxt) *nxt++ = '\0'; force_level++; if (*ptr) process_command(obj, ptr); force_level--; ptr = nxt; } while (ptr); *buf = '\0'; return ""; }
int can_link_to(dbref who, object_flag_type what_type, dbref where) { /* Can always link to HOME */ if (where == HOME) return 1; /* Can't link to an invalid dbref */ if (where < 0 || where >= db_top) return 0; switch (what_type) { case TYPE_EXIT: /* If the target is LINK_OK, then any exit may be linked * there. Otherwise, only someone who controls the * target may link there. */ return (controls(who, where) || (FLAGS(where) & LINK_OK)); /* NOTREACHED */ break; case TYPE_PLAYER: /* Players may only be linked to rooms, that are either * controlled by the player or set either L or A. */ return (Typeof(where) == TYPE_ROOM && (controls(who, where) || Linkable(where))); /* NOTREACHED */ break; case TYPE_ROOM: /* Rooms may be linked to rooms or things (this sets their * dropto location). Target must be controlled, or be L or A. */ return ((Typeof(where) == TYPE_ROOM || Typeof(where) == TYPE_THING) && (controls(who, where) || Linkable(where))); /* NOTREACHED */ break; case TYPE_THING: /* Things may be linked to rooms, players, or other things (this * sets the thing's home). Target must be controlled, or be L or A. */ return ( (Typeof(where) == TYPE_ROOM || Typeof(where) == TYPE_PLAYER || Typeof(where) == TYPE_THING) && (controls(who, where) || Linkable(where))); /* NOTREACHED */ break; case NOTYPE: /* Why is this here? -winged */ return (controls(who, where) || (FLAGS(where) & LINK_OK) || (Typeof(where) != TYPE_THING && (FLAGS(where) & ABODE))); /* NOTREACHED */ break; default: /* Programs can't be linked anywhere */ return 0; /* NOTREACHED */ break; } /* NOTREACHED */ return 0; }
int fetchprops_priority(dbref obj, int mode, const char *pdir) { const char *s; int hitflag = 0; /* update fetched timestamp */ DBFETCH(obj)->propstime = time(NULL); /* if in memory, don't try to reload. */ if (DBFETCH(obj)->propsmode != PROPS_UNLOADED) { /* but do update the queue position */ addobject_ringqueue(obj, DBFETCH(obj)->propsmode); if (!pdir) pdir = "/"; while ((s = propdir_unloaded(DBFETCH(obj)->properties, pdir))) { propcache_misses++; hitflag++; if (!mode) update_fetchstats(); if (FLAGS(obj) & SAVED_DELTA) { getproperties(delta_infile, obj, s); } else { getproperties(input_file, obj, s); } } if (hitflag) { return 1; } else { propcache_hits++; return 0; } } propcache_misses++; housecleanprops(); /* actually load in root properties from the appropriate file */ if (FLAGS(obj) & SAVED_DELTA) { getproperties(delta_infile, obj, "/"); } else { getproperties(input_file, obj, "/"); } /* update fetch statistics */ if (!mode) update_fetchstats(); /* add object to appropriate queue */ addobject_ringqueue(obj, ((mode) ? PROPS_PRIORITY : PROPS_LOADED)); return 1; }
/*** makedirty * * * Input: * * Output: * *************************************************************************/ void makedirty ( REGISTER PFILE pFileDirty ) { if (!TESTFLAG(FLAGS(pFileDirty),DIRTY)) { if (pFileDirty == pFileHead) { SETFLAG (fDisplay, RSTATUS); } SETFLAG (FLAGS(pFileDirty), DIRTY); } }
const char * mfn_contents(MFUNARGS) { char buf2[50]; int list_limit = MAX_MFUN_LIST_LEN; dbref obj = mesg_dbref_local(player, what, perms, argv[0]); int typchk, ownroom; int outlen, nextlen; if (obj == AMBIGUOUS || obj == UNKNOWN || obj == NOTHING || obj == HOME) ABORT_MPI("CONTENTS","Match failed"); if (obj == PERMDENIED) ABORT_MPI("CONTENTS",NOPERM_MESG); typchk = NOTYPE; if (argc > 1) { if (!string_compare(argv[1], "Room")) { typchk = TYPE_ROOM; } else if (!string_compare(argv[1], "Exit")) { typchk = TYPE_EXIT; /* won't find any, though */ } else if (!string_compare(argv[1], "Player")) { typchk = TYPE_PLAYER; } else if (!string_compare(argv[1], "Program")) { typchk = TYPE_PROGRAM; } else if (!string_compare(argv[1], "Thing")) { typchk = TYPE_THING; } else { ABORT_MPI("CONTENTS","Type must be 'player', 'room', 'thing', 'program', or 'exit'. (2)"); } } strcpy(buf, ""); outlen = 0; ownroom = controls(perms, obj); obj = DBFETCH(obj)->contents; while (obj != NOTHING && list_limit) { if ((typchk == NOTYPE || Typeof(obj) == typchk) && (ownroom || controls(perms, obj) || !((FLAGS(obj) & DARK) || (FLAGS(getloc(obj)) & DARK) || (Typeof(obj) == TYPE_PROGRAM && !(FLAGS(obj) & LINK_OK)))) && !(Typeof(obj) == TYPE_ROOM && typchk != TYPE_ROOM)) { ref2str(obj, buf2); nextlen = strlen(buf2); if ((outlen + nextlen) >= (BUFFER_LEN - 3)) break; if (outlen) strcat((buf+(outlen++)), "\r"); strcat((buf + outlen), buf2); outlen += nextlen; list_limit--; } obj = DBFETCH(obj)->next; } return buf; }
dbref find_mlev(dbref prog, struct frame * fr, int st) { if ((FLAGS(prog) & STICKY) && (FLAGS(prog) & HAVEN)) { if ((st > 1) && (TrueWizard(OWNER(prog)))) return (find_mlev(fr->caller.st[st - 1], fr, st - 1)); } if (MLevel(prog) < MLevel(OWNER(prog))) { return (MLevel(prog)); } else { return (MLevel(OWNER(prog))); } }
/** * List program lines to a player * * This is used by the debugger for listing lines and for backtraces. * Uses the editor's list_program under the hood. * * @see list_program * * @param player the player to send the listing to * @param program the program to list * @param fr the running program frame * @param start the start line * @param end the end line */ void list_proglines(dbref player, dbref program, struct frame *fr, int start, int end) { int range[2]; int argc; if (start == end || end == 0) { range[0] = start; range[1] = start; argc = 1; } else { range[0] = start; range[1] = end; argc = 2; } /* Make sure we have the lines of code loaded for display */ if (!fr->brkpt.proglines || program != fr->brkpt.lastproglisted) { free_prog_text(fr->brkpt.proglines); fr->brkpt.proglines = (struct line *) read_program(program); fr->brkpt.lastproglisted = program; } { /* * We have to change the program position in order to do the * listing, so we use this tmpline so we can reset it when * we are done. */ struct line *tmpline = PROGRAM_FIRST(program); PROGRAM_SET_FIRST(program, fr->brkpt.proglines); { int tmpflg = (FLAGS(player) & INTERNAL); FLAGS(player) |= INTERNAL; list_program(player, program, range, argc, 0); if (!tmpflg) { FLAGS(player) &= ~INTERNAL; } } PROGRAM_SET_FIRST(program, tmpline); } return; }
bool can_link_to(dbref who, object_flag_type what_type, dbref where) { if (where == HOME) return 1; if (where == NIL) return 1; if (!OkObj(who) || !OkObj(where)) return 0; switch (what_type) { case TYPE_EXIT: return (controls(who, where) || (FLAGS(where) & LINK_OK) || (POWERS(who) & POW_LINK_ANYWHERE)); /* NOTREACHED */ break; case TYPE_PLAYER: return (Typeof(where) == TYPE_ROOM && (controls(who, where) || Linkable(where) || (POWERS(who) & POW_LINK_ANYWHERE))); /* NOTREACHED */ break; case TYPE_ROOM: return ((Typeof(where) == TYPE_ROOM || Typeof(where) == TYPE_THING) && (controls(who, where) || Linkable(where) || (POWERS(who) & POW_LINK_ANYWHERE))); /* NOTREACHED */ break; case TYPE_THING: return ((Typeof(where) == TYPE_ROOM || Typeof(where) == TYPE_PLAYER || Typeof(where) == TYPE_THING) && (controls(who, where) || Linkable(where) || (POWERS(who) & POW_LINK_ANYWHERE))); /* NOTREACHED */ break; case NOTYPE: return (controls(who, where) || (FLAGS(where) & LINK_OK) || (POWERS(who) & POW_LINK_ANYWHERE) || (Typeof(where) != TYPE_THING && (FLAGS(where) & ABODE))); /* NOTREACHED */ break; } return 0; }
void do_edit(int descr, dbref player, const char *name) { dbref i; struct match_data md; if (Typeof(player) != TYPE_PLAYER) { anotify_nolisten2(player, CFAIL "Only players can edit programs."); return; } else if (!Mucker(player)) { anotify_nolisten2(player, CFAIL NOMBIT_MESG); return; } else if (tp_db_readonly) { anotify_nolisten2(player, CFAIL DBRO_MESG); return; } else if (!*name) { anotify_nolisten2(player, CINFO "No program name given."); return; } init_match(descr, player, name, TYPE_PROGRAM, &md); match_possession(&md); match_neighbor(&md); match_registered(&md); match_absolute(&md); if ((i = noisy_match_result(&md)) == NOTHING || i == AMBIGUOUS) return; if ((Typeof(i) != TYPE_PROGRAM) || !controls(player, i)) { anotify_fmt(player, CFAIL "%s", tp_noperm_mesg); return; } else if (FLAGS(i) & INTERNAL) { anotify_nolisten2(player, CFAIL NOEDIT_MESG); return; } FLAGS(i) |= INTERNAL; DBFETCH(i)->sp.program.first = read_program(i); DBFETCH(player)->sp.player.curr_prog = i; anotify_fmt(player, CINFO "Entering editor for %s.", unparse_object(player, i)); /* list current line */ do_list(player, i, 0, 0, 0); FLAGS(player) |= INTERACTIVE; DBDIRTY(i); DBDIRTY(player); }
int time_for_monolithic(void) { dbref i; int count = 0; int a, b; if (!last_monolithic_time) last_monolithic_time = time(NULL); if (time(NULL) - last_monolithic_time >= (tp_monolithic_interval - tp_dump_warntime) ) { return 1; } for (i = 0; i < db_top; i++) if (FLAGS(i) & (SAVED_DELTA | OBJECT_CHANGED)) count++; if (((count * 100) / db_top) > tp_max_delta_objs) { return 1; } fseek(delta_infile, 0L, 2); a = ftell(delta_infile); fseek(input_file, 0L, 2); b = ftell(input_file); if (a >= b) { return 1; } return 0; }
/* doesn't really belong here, but I couldn't figure out where else */ void do_page(dbref player, const char *arg1, const char *arg2) { int ignored; char buf[BUFFER_LEN], buf2[BUFFER_LEN]; dbref target; if (!payfor(player, tp_lookup_cost)) { anotify_fmt(player, CFAIL "You don't have enough %s.", tp_pennies); return; } if ( strcmp(arg1, "me") ) { if ((target = lookup_player(arg1)) == NOTHING) { anotify(player, CINFO WHO_MESG); return; } } else target = player; if(Guest(player)) { if(!Mage(target)) { anotify(player, CINFO "Guests can only page " NAMEWIZ "s, type 'wizzes'."); return; } } if (FLAGS(target) & HAVEN) { anotify(player, CFAIL "That player is haven."); return; } ignored = ignoring(target, player); if(ignored == 1) { anotify(player, CFAIL "That player is ignoring you."); return; } else if(ignored == 2) { anotify(player, CINFO "That player is ignoring you."); } do_parse_mesg(player, player, arg2, "(page)", buf, MPI_ISPRIVATE); tct(buf,buf2); if (!*buf2) { sprintf(buf, CGREEN "You sense that %s is looking for you in %s.", PNAME(player), NAME(DBFETCH(player)->location)); } else { if(buf2[0] == ':' || buf2[0] == ';') { sprintf(buf, CGREEN "%s pages \"" CYELLOW "%s %.3900s" CGREEN "\"", PNAME(player), PNAME(player), buf2); } else { sprintf(buf, CGREEN "%s pages \"" CYELLOW "%.3900s" CGREEN "\"", PNAME(player), buf2); } } if (anotify_from(player, target, buf)) anotify(player, CSUCC "Your message has been sent."); else { sprintf(buf, CINFO "%s is not connected.", PNAME(target)); anotify(player, buf); } }
/* FileStatus - compare logical info about a file with file on disk * * Compare the last modified time with the last snapshot. If the filename * contains metachars, the file is not believed to have changed. Further, if * the file is a pseudo file, it cannot have changed. * * pFile file of interest (contains mod time) * pName name of file to examine (when writing to diff. name) * * returns FILECHANGED if timestamps differ * FILEDELETED if file on disk does not exist * FILESAME if timestamps are the same */ int FileStatus ( PFILE pFile, char *pName ){ long modtime; if (TESTFLAG(FLAGS(pFile),FAKE)) { return FILESAME; } if (pName == NULL) { pName = pFile->pName; } if (*strbscan (pName, "?*") != 0) { return FILESAME; } if ((modtime = ModTime (pName)) == 0L) { return FILEDELETED; } if (pFile->modify != modtime) { return FILECHANGED; } return FILESAME; }
/* fSyncFile - Attempt to make logical file and physical file the same * * When editing in a network or multi-tasking environment, we need to make * sure that changes made underneath us are properly reflected to the * user. We do this by snapshotting the time-of-last-write and periodically * comparing it with the version on disk. When a mismatch is found, we * prompt the user and give him the opportunity to reread the file * * pFileLoc file structure of interest * fPrompt TRUE => prompt user for permission to refresh, else just * refresh. * * returns TRUE iff the logical file and the physical file are the same. */ flagType fSyncFile ( PFILE pFileLoc, flagType fPrompt ) { if (pFileLoc == NULL) { pFileLoc = pFileHead; } switch (FileStatus (pFileLoc, NULL)) { case FILECHANGED: if (!confirmx("%s has been changed. Refresh? ", pFileLoc->pName)) { /* No, validate this edit session */ SetModTime (pFileLoc); return FALSE; } FileRead (strcpy( buf, pFileLoc->pName ), pFileLoc, TRUE); RSETFLAG (FLAGS (pFileLoc), DIRTY); SETFLAG (fDisplay, RSTATUS); return TRUE; case FILEDELETED: domessage ("File has been deleted"); break; default: break; } return TRUE; }
/* doesn't really belong here, but I couldn't figure out where else */ void do_page(dbref player, const char *arg1, const char *arg2) { char buf[BUFFER_LEN]; dbref target; if (!payfor(player, tp_lookup_cost)) { notify_fmt(player, "You don't have enough %s.", tp_pennies); return; } if ((target = lookup_player(arg1)) == NOTHING) { notify(player, "I don't recognize that name."); return; } if (FLAGS(target) & HAVEN) { notify(player, "That player does not wish to be disturbed."); return; } if (blank(arg2)) snprintf(buf, sizeof(buf), "You sense that %s is looking for you in %s.", NAME(player), NAME(DBFETCH(player)->location)); else snprintf(buf, sizeof(buf), "%s pages from %s: \"%s\"", NAME(player), NAME(DBFETCH(player)->location), arg2); if (notify_from(player, target, buf)) notify(player, "Your message has been sent."); else { snprintf(buf, sizeof(buf), "%s is not connected.", NAME(target)); notify(player, buf); } }
/* * Apply a relocation to an image being built from an input file. Use the * runtime linkers routines to do the necessary magic. */ void apply_reloc(void *vrel, Reloc *reloc, const char *name, uchar_t *oaddr, Rt_map *lmp) { Rela *rel = vrel; Xword type = ELF_R_TYPE(rel->r_info, M_MACH); Xword value = reloc->r_value + rel->r_addend; if (type == R_AMD64_JUMP_SLOT) { uintptr_t addr, vaddr; if (FLAGS(lmp) & FLG_RT_FIXED) vaddr = 0; else vaddr = ADDR(lmp); addr = (uintptr_t)oaddr - rel->r_offset; /* LINTED */ (void) elf_plt_write((uintptr_t)addr, vaddr, rel, (uintptr_t)value, reloc->r_pltndx); } else if (type == R_AMD64_COPY) { (void) memcpy((void *)oaddr, (void *)value, (size_t)reloc->r_size); } else { (void) do_reloc_rtld(type, oaddr, &value, reloc->r_name, name, LIST(lmp)); } }
void mcpedit_program(int descr, dbref player, dbref prog, const char *name, McpFrame *mfr) { char namestr[BUFFER_LEN]; char refstr[BUFFER_LEN]; struct line *curr; McpMesg msg; McpVer supp; supp = mcp_frame_package_supported(mfr, "dns-org-mud-moo-simpleedit"); if (supp.verminor == 0 && supp.vermajor == 0) { do_prog(descr, player, name); return; } FLAGS(prog) |= INTERNAL; snprintf(refstr, sizeof(refstr), "%d.prog.", prog); snprintf(namestr, sizeof(namestr), "a program named %s(%d)", NAME(prog), prog); mcp_mesg_init(&msg, "dns-org-mud-moo-simpleedit", "content"); mcp_mesg_arg_append(&msg, "reference", refstr); mcp_mesg_arg_append(&msg, "type", "muf-code"); mcp_mesg_arg_append(&msg, "name", namestr); for (curr = DBFETCH(prog)->sp.program.first; curr; curr = curr->next) mcp_mesg_arg_append(&msg, "content", DoNull(curr->this_line)); mcp_frame_output_mesg(mfr, &msg); mcp_mesg_clear(&msg); free_prog_text(DBFETCH(prog)->sp.program.first); DBFETCH(prog)->sp.program.first = NULL; }
//*********************************************** uint8_t ColYuvRgb::reset(uint32_t ww, uint32_t hh) { int flags=0; CLEANUP(); FLAGS(); PixelFormat fmt=TARGET_COLORSPACE; if(_inverted) fmt=ALTERNATE_COLORSPACE; if(!ww || !hh) return 0; if (_context) sws_freeContext((SwsContext *)_context); /* FIXME: remove when ffmpeg is fixed Without SWS_ACCURATE_RND the quality is bad for YUV->RGB (caused by libswscale r28700) */ flags |= SWS_ACCURATE_RND; _context=(void *)sws_getContext( ww,hh, PIX_FMT_YUV420P , ww,hh, fmt, flags, NULL, NULL,NULL); if(!_context) ADM_assert(0); w=ww; h=hh; return 1; }
BOOL PEXPORT KppMakeCRule(ATOMID idName, ATOMID (PEXPORT *pIfPart)(), void (PEXPORT *pThenPart)(), short sPrio) { #ifdef INFERENCE BOOL bExists = FALSE; RULEID idRule; LPRULE lpRule; if (!KppIsGoodAtom(idName)) return FALSE; idRule = KppGetItemFromName(RULE, idName, (LPLPSTR) &lpRule); if (idRule) bExists = TRUE; else if (!(idRule = KppAddItemAndName(RULE, (LPLPSTR) &lpRule, idName))) return FALSE; NAME(lpRule) = idName; FLAGS(lpRule) = CBODY; PRIORITY(lpRule) = sPrio; CIFPTR(lpRule) = pIfPart; CTHENPTR(lpRule) = (ATOMID (PEXPORT *)()) pThenPart; CIFPAIRS(lpRule) = NULLID; CTHENPAIRS(lpRule) = NULLID; KppReleaseItem(RULE, idRule); /* Add to KnowledgeTools */ if (!bExists) KppAddItemCB(RULE, 1); KppChangeRuleCB(); return TRUE; #endif }
/**************************************************************** ** C GOAL function *****************************************************************/ BOOL PEXPORT KppMakeCGoal(ATOMID idName, LOGICALID (PEXPORT *pGoal)(void)) { BOOL bExists = FALSE; GOALID idGoal = NULLID; LPGOAL lpGoal; #ifdef INFERENCE if (!KppIsGoodAtom(idName)) return FALSE; idGoal = KppGetItemFromName(GOAL, idName, (LPLPSTR) &lpGoal); if (idGoal) bExists = TRUE; else if (!(idGoal = KppAddItemAndName(GOAL, (LPLPSTR) &lpGoal, idName))) return FALSE; NAME(lpGoal) = idName; FLAGS(lpGoal) = CBODY; PRIORITY(lpGoal) = 0; CBODYPTR(lpGoal) = pGoal; KppReleaseItem(GOAL, idGoal); /* Add to KnowledgeTools */ if (!bExists) KppAddItemCB(GOAL, 1); #endif return idGoal; }