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