src/p.functions.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
char *	trim_space_sep (char *str, int sep)
char *	next_token (char *str, int sep)
char *	split_token (char **sp, int sep)
dbref	match_thing (dbref player, char *name)
int	list2arr (char *arr[], int maxlen, char *list, int sep)
void	arr2list (char *arr[], int alen, char *list, char **bufc, int sep)
int	nearby_or_control (dbref player, dbref thing)
int	fn_range_check (const char *fname, int nfargs, int minargs, int maxargs, char *result, char **bufc)
int	delim_check (char *fargs[], int nfargs, int sep_arg, char *sep, char *buff, char **bufc, int eval, dbref player, dbref cause, char *cargs[], int ncargs)
int	countwords (char *str, int sep)
time_t	mytime (dbref player)
int	do_convtime (char *str, struct tm *ttm)
char *	get_uptime_to_string (int uptime)
char *	get_uptime_to_short_string (int uptime)
int	check_read_perms (dbref player, dbref thing, ATTR *attr, int aowner, int aflags, char *buff, char **bufc)
int	xlate (char *arg)
void	init_functab (void)
void	do_function (dbref player, dbref cause, int key, char *fname, char *target)
void	list_functable (dbref player)
int	cf_func_access (int *vp, char *str, long extra, dbref player, char *cmd)

---

Function Documentation

void arr2list	(	char *	arr[],
		int	alen,
		char *	list,
		char **	bufc,
		int	sep
	)

int cf_func_access	(	int *	vp,
		char *	str,
		long	extra,
		dbref	player,
		char *	cmd
	)

Definition at line 5985 of file functions.c.

References cf_modify_bits(), flist, fun::name, fun::perms, and string_compare().

{
        FUN *fp;
        UFUN *ufp;
        char *ap;

        for(ap = str; *ap && !isspace(*ap); ap++);
        if(*ap)
                *ap++ = '\0';

        for(fp = flist; fp->name; fp++) {
                if(!string_compare(fp->name, str)) {
                        return (cf_modify_bits(&fp->perms, ap, extra, player, cmd));
                }
        }
        for(ufp = ufun_head; ufp; ufp = ufp->next) {
                if(!string_compare(ufp->name, str)) {
                        return (cf_modify_bits(&ufp->perms, ap, extra, player, cmd));
                }
        }
        cf_log_notfound(player, cmd, "Function", str);
        return -1;
}

int check_read_perms	(	dbref	player,
		dbref	thing,
		ATTR *	attr,
		int	aowner,
		int	aflags,
		char *	buff,
		char **	bufc
	)

Get attribute from object.

Definition at line 1030 of file functions.c.

References A_DESC, attr, Examinable, mudconf, nearby(), attr::number, confdata::read_rem_desc, safe_str, See_All, See_attr, and See_attr_explicit.

{
        int see_it;

        /*
         * If we have explicit read permission to the attr, return it 
         */

        if(See_attr_explicit(player, thing, attr, aowner, aflags))
                return 1;

        /*
         * If we are nearby or have examine privs to the attr and it is * * * 
         * 
         * * visible to us, return it. 
         */

        see_it = See_attr(player, thing, attr, aowner, aflags);
        if((Examinable(player, thing) || nearby(player, thing) ||
                See_All(player)) && see_it)
                return 1;

        /*
         * For any object, we can read its visible attributes, EXCEPT * for * 
         * 
         * *  * * descs, which are only visible if read_rem_desc is on. 
         */

        if(see_it) {
                if(!mudconf.read_rem_desc && (attr->number == A_DESC)) {
                        safe_str("#-1 TOO FAR AWAY TO SEE", buff, bufc);
                        return 0;
                } else {
                        return 1;
                }
        }
        safe_str("#-1 PERMISSION DENIED", buff, bufc);
        return 0;
}

int countwords	(	char *	str,
		int	sep
	)

int delim_check	(	char *	fargs[],
		int	nfargs,
		int	sep_arg,
		char *	sep,
		char *	buff,
		char **	bufc,
		int	eval,
		dbref	player,
		dbref	cause,
		char *	cargs[],
		int	ncargs
	)

* delim_check: obtain delimiter

Definition at line 489 of file functions.c.

References alloc_lbuf, EV_EVAL, EV_FCHECK, exec(), free_lbuf, and safe_str.

{
        char *tstr, *bp, *str;
        int tlen;

        if(nfargs >= sep_arg) {
                tlen = strlen(fargs[sep_arg - 1]);
                if(tlen <= 1)
                        eval = 0;
                if(eval) {
                        tstr = bp = alloc_lbuf("delim_check");
                        str = fargs[sep_arg - 1];
                        exec(tstr, &bp, 0, player, cause, EV_EVAL | EV_FCHECK, &str,
                                 cargs, ncargs);
                        *bp = '\0';
                        tlen = strlen(tstr);
                        *sep = *tstr;
                        free_lbuf(tstr);
                }
                if(tlen == 0) {
                        *sep = ' ';
                } else if(tlen != 1) {
                        safe_str("#-1 SEPARATOR MUST BE ONE CHARACTER", buff, bufc);
                        return 0;
                } else if(!eval) {
                        *sep = *fargs[sep_arg - 1];
                }
        } else {
                *sep = ' ';
        }
        return 1;
}

int do_convtime	(	char *	str,
		struct tm *	ttm
	)

Definition at line 732 of file functions.c.

References alloc_sbuf, daystab, free_sbuf, get_substr, LEAPYEAR_1900, monthtab, safe_sb_str, and string_compare().

Referenced by check_mail_expiration(), fun_convtime(), and mail_match().

{
        char *buf, *p, *q;
        int i;

        if(!str || !ttm)
                return 0;
        while (*str == ' ')
                str++;
        buf = p = alloc_sbuf("do_convtime");    /*
                                                                                         * make a temp copy of arg 
                                                                                         */
        safe_sb_str(str, buf, &p);
        *p = '\0';

        get_substr(buf, p);                     /*
                                                                 * day-of-week or month 
                                                                 */
        if(!p || strlen(buf) != 3) {
                free_sbuf(buf);
                return 0;
        }
        for(i = 0; (i < 12) && string_compare(monthtab[i], p); i++);
        if(i == 12) {
                get_substr(p, q);               /*
                                                                 * month 
                                                                 */
                if(!q || strlen(p) != 3) {
                        free_sbuf(buf);
                        return 0;
                }
                for(i = 0; (i < 12) && string_compare(monthtab[i], p); i++);
                if(i == 12) {
                        free_sbuf(buf);
                        return 0;
                }
                p = q;
        }
        ttm->tm_mon = i;

        get_substr(p, q);                       /*
                                                                 * day of month 
                                                                 */
        if(!q || (ttm->tm_mday = atoi(p)) < 1 || ttm->tm_mday > daystab[i]) {
                free_sbuf(buf);
                return 0;
        }
        p = (char *) index(q, ':');     /*
                                                                 * hours 
                                                                 */
        if(!p) {
                free_sbuf(buf);
                return 0;
        }
        *p++ = '\0';
        if((ttm->tm_hour = atoi(q)) > 23 || ttm->tm_hour < 0) {
                free_sbuf(buf);
                return 0;
        }
        if(ttm->tm_hour == 0) {
                while (isspace(*q))
                        q++;
                if(*q != '0') {
                        free_sbuf(buf);
                        return 0;
                }
        }
        q = (char *) index(p, ':');     /*
                                                                 * minutes 
                                                                 */
        if(!q) {
                free_sbuf(buf);
                return 0;
        }
        *q++ = '\0';
        if((ttm->tm_min = atoi(p)) > 59 || ttm->tm_min < 0) {
                free_sbuf(buf);
                return 0;
        }
        if(ttm->tm_min == 0) {
                while (isspace(*p))
                        p++;
                if(*p != '0') {
                        free_sbuf(buf);
                        return 0;
                }
        }
        get_substr(q, p);                       /*
                                                                 * seconds 
                                                                 */
        if(!p || (ttm->tm_sec = atoi(q)) > 59 || ttm->tm_sec < 0) {
                free_sbuf(buf);
                return 0;
        }
        if(ttm->tm_sec == 0) {
                while (isspace(*q))
                        q++;
                if(*q != '0') {
                        free_sbuf(buf);
                        return 0;
                }
        }
        get_substr(p, q);                       /*
                                                                 * year 
                                                                 */
        if((ttm->tm_year = atoi(p)) == 0) {
                while (isspace(*p))
                        p++;
                if(*p != '0') {
                        free_sbuf(buf);
                        return 0;
                }
        }
        free_sbuf(buf);
        if(ttm->tm_year > 100)
                ttm->tm_year -= 1900;
        if(ttm->tm_year < 0) {
                return 0;
        }
#define LEAPYEAR_1900(yr) ((yr)%400==100||((yr)%100!=0&&(yr)%4==0))
        return (ttm->tm_mday != 29 || i != 1 || LEAPYEAR_1900(ttm->tm_year));
#undef LEAPYEAR_1900
}

void do_function	(	dbref	player,
		dbref	cause,
		int	key,
		char *	fname,
		char *	target
	)

Definition at line 5831 of file functions.c.

References alloc_sbuf, free_sbuf, statedata::func_htab, hashfind(), mudstate, notify_quiet, safe_sb_str, and ToLower.

{
        UFUN *ufp, *ufp2;
        ATTR *ap;
        char *np, *bp;
        int atr, aflags;
        dbref obj, aowner;

        /*
         * Make a local uppercase copy of the function name 
         */

        bp = np = alloc_sbuf("add_user_func");
        safe_sb_str(fname, np, &bp);
        *bp = '\0';
        for(bp = np; *bp; bp++)
                *bp = ToLower(*bp);

        /*
         * Verify that the function doesn't exist in the builtin table 
         */

        if(hashfind(np, &mudstate.func_htab) != NULL) {
                notify_quiet(player,
                                         "Function already defined in builtin function table.");
                free_sbuf(np);
                return;
        }
        /*
         * Make sure the target object exists 
         */

        if(!parse_attrib(player, target, &obj, &atr)) {
                notify_quiet(player, "I don't see that here.");
                free_sbuf(np);
                return;
        }
        /*
         * Make sure the attribute exists 
         */

        if(atr == NOTHING) {
                notify_quiet(player, "No such attribute.");
                free_sbuf(np);
                return;
        }
        /*
         * Make sure attribute is readably by me 
         */

        ap = atr_num(atr);
        if(!ap) {
                notify_quiet(player, "No such attribute.");
                free_sbuf(np);
                return;
        }
        atr_get_info(obj, atr, &aowner, &aflags);
        if(!See_attr(player, obj, ap, aowner, aflags)) {
                notify_quiet(player, "Permission denied.");
                free_sbuf(np);
                return;
        }
        /*
         * Privileged functions require you control the obj.  
         */

        if((key & FN_PRIV) && !Controls(player, obj)) {
                notify_quiet(player, "Permission denied.");
                free_sbuf(np);
                return;
        }
        /*
         * See if function already exists.  If so, redefine it 
         */

        ufp = (UFUN *) hashfind(np, &mudstate.ufunc_htab);

        if(!ufp) {
                ufp = (UFUN *) malloc(sizeof(UFUN));
                ufp->name = strsave(np);
                for(bp = (char *) ufp->name; *bp; bp++)
                        *bp = ToUpper(*bp);
                ufp->obj = obj;
                ufp->atr = atr;
                ufp->perms = CA_PUBLIC;
                ufp->next = NULL;
                if(!ufun_head) {
                        ufun_head = ufp;
                } else {
                        for(ufp2 = ufun_head; ufp2->next; ufp2 = ufp2->next);
                        ufp2->next = ufp;
                }
                hashadd(np, (int *) ufp, &mudstate.ufunc_htab);
        }
        ufp->obj = obj;
        ufp->atr = atr;
        ufp->flags = key;
        free_sbuf(np);
        if(!Quiet(player)) {
        char buffer[MBUF_SIZE];
        snprintf(buffer, MBUF_SIZE - 1, "Function %s defined.", fname);
        notify_quiet(player, buffer);
    }
}

int fn_range_check	(	const char *	fname,
		int	nfargs,
		int	minargs,
		int	maxargs,
		char *	result,
		char **	bufc
	)

Check # of args to a function with an optional argument for validity.

Definition at line 469 of file functions.c.

References safe_tprintf_str().

{
        if((nfargs >= minargs) && (nfargs <= maxargs))
                return 1;

        if(maxargs == (minargs + 1))
                safe_tprintf_str(result, bufc,
                                                 "#-1 FUNCTION (%s) EXPECTS %d OR %d ARGUMENTS",
                                                 fname, minargs, maxargs);
        else
                safe_tprintf_str(result, bufc,
                                                 "#-1 FUNCTION (%s) EXPECTS BETWEEN %d AND %d ARGUMENTS",
                                                 fname, minargs, maxargs);
        return 0;
}

char* get_uptime_to_short_string

(

int

uptime

)

Definition at line 932 of file functions.c.

References alloc_sbuf, multip, sname, uptime_unit_table, and UPTIME_UNITS.

{
        char *buf = alloc_sbuf("get_uptime_to_string");
        int units[UPTIME_UNITS];
        int taim = uptime;
        int ut = 0, uc = 0, foofaa;

        if(uptime <= 0) {
                strcpy(buf, "#-1 INVALID VALUE");
                return buf;
        }
        for(ut = 0; ut < UPTIME_UNITS; ut++)
                units[ut] = 0;
        ut = 0;
        buf[0] = 0;
        while (taim > 0) {
                if((foofaa = (taim / uptime_unit_table[ut].multip)) > 0) {
                        uc++;
                        units[ut] = foofaa;
                        taim -= uptime_unit_table[ut].multip * foofaa;
                }
                ut++;
        }
        /*
         * Now, we got it..
         */
        for(ut = 0; ut < UPTIME_UNITS; ut++) {
                if(units[ut]) {
                        uc--;
                        if(units[ut] > 1)
                                sprintf(buf + strlen(buf), "%d%s", units[ut],
                                                uptime_unit_table[ut].sname);
                        else
                                sprintf(buf + strlen(buf), "%d%s", units[ut],
                                                uptime_unit_table[ut].sname);
                        if(uc > 0)
                                strcat(buf, " ");
                }
        }
        return buf;
}

char* get_uptime_to_string

(

int

uptime

)

Definition at line 888 of file functions.c.

References alloc_sbuf, multip, name, uptime_unit_table, and UPTIME_UNITS.

Referenced by do_comwho(), fun_convuptime(), and silly_get_uptime_to_string().

{
        char *buf = alloc_sbuf("get_uptime_to_string");
        int units[UPTIME_UNITS];
        int taim = uptime;
        int ut = 0, uc = 0, foofaa;

        if(uptime <= 0) {
                strcpy(buf, "#-1 INVALID VALUE");
                return buf;
        }
        for(ut = 0; ut < UPTIME_UNITS; ut++)
                units[ut] = 0;
        ut = 0;
        buf[0] = 0;
        while (taim > 0) {
                if((foofaa = (taim / uptime_unit_table[ut].multip)) > 0) {
                        uc++;
                        units[ut] = foofaa;
                        taim -= uptime_unit_table[ut].multip * foofaa;
                }
                ut++;
        }
        /*
         * Now, we got it..
         */
        for(ut = 0; ut < UPTIME_UNITS; ut++) {
                if(units[ut]) {
                        uc--;
                        if(units[ut] > 1)
                                sprintf(buf + strlen(buf), "%d %ss", units[ut],
                                                uptime_unit_table[ut].name);
                        else
                                sprintf(buf + strlen(buf), "%d %s", units[ut],
                                                uptime_unit_table[ut].name);
                        if(uc > 1)
                                strcat(buf, ", ");
                        else if(uc > 0)
                                strcat(buf, " and ");
                }
        }
        return buf;
}

void init_functab

(

void

)

Definition at line 5808 of file functions.c.

References alloc_sbuf, flist, free_sbuf, statedata::func_htab, HASH_FACTOR, hashadd(), hashinit(), mudstate, fun::name, ToLower, ufun_head, and statedata::ufunc_htab.

Referenced by main().

{
        FUN *fp;
        char *buff, *cp, *dp;

        buff = alloc_sbuf("init_functab");
        hashinit(&mudstate.func_htab, 100 * HASH_FACTOR);
        for(fp = flist; fp->name; fp++) {
                cp = (char *) fp->name;
                dp = buff;
                while (*cp) {
                        *dp = ToLower(*cp);
                        cp++;
                        dp++;
                }
                *dp = '\0';
                hashadd(buff, (int *) fp, &mudstate.func_htab);
        }
        free_sbuf(buff);
        ufun_head = NULL;
        hashinit(&mudstate.ufunc_htab, 11);
}

int list2arr	(	char *	arr[],
		int	maxlen,
		char *	list,
		int	sep
	)

void list_functable

(

dbref

player

)

Definition at line 5942 of file functions.c.

References alloc_lbuf, check_access(), flist, fun::name, and fun::perms.

Referenced by do_list().

{
        FUN *fp;
        UFUN *ufp;
        char *buf, *bp, *cp;

        buf = alloc_lbuf("list_functable");
        bp = buf;

        /* Hardcoded Functions */
        for(cp = (char *) "Functions:"; *cp; cp++)
                *bp++ = *cp;
        for(fp = flist; fp->name; fp++) {
                if(check_access(player, fp->perms)) {
                        *bp++ = ' ';
                        for(cp = (char *) (fp->name); *cp; cp++)
                                *bp++ = *cp;
                }
        }
        *bp = '\0';
        notify(player, buf);

        /* User-Defined functions (via @function) */
        bp = buf;
        safe_str("User-Functions:", buf, &bp);

        for(ufp = ufun_head; ufp; ufp = ufp->next) {
                if(check_access(player, ufp->perms)) {
                        *bp++ = ' ';
                        for(cp = (char *) (ufp->name); *cp; cp++)
                                *bp++ = *cp;
                }
        }
        *bp = '\0';
        notify(player, buf);
        free_lbuf(buf);
}

dbref match_thing	(	dbref	player,
		char *	name
	)

Definition at line 289 of file functions.c.

{
        init_match(player, name, NOTYPE);
        match_everything(MAT_EXIT_PARENTS);
        return (noisy_match_result());
}

time_t mytime

(

dbref

player

)

Definition at line 625 of file functions.c.

References A_TZ, mudstate, statedata::now, and silly_atr_get().

{
        struct timeval tv;
        struct timezone tz;
        char *tzstr;
        int hours, dst;

        tzstr = silly_atr_get(player, A_TZ);
        if(sscanf(tzstr, "%d:%d", &hours, &dst) < 2)
                return mudstate.now;
        tz.tz_minuteswest = (0 - hours) * 60;
        tz.tz_dsttime = dst;
        gettimeofday(&tv, &tz);
        return tv.tv_sec;
}

int nearby_or_control	(	dbref	player,
		dbref	thing
	)

Check if player is near or controls thing

Definition at line 421 of file functions.c.

References Controls, Good_obj, and nearby().

Referenced by fun_elock(), fun_fullname(), fun_name(), fun_nearby(), and process_sex().

{
        if(!Good_obj(player) || !Good_obj(thing))
                return 0;
        if(Controls(player, thing))
                return 1;
        if(!nearby(player, thing))
                return 0;
        return 1;
}

char* next_token	(	char *	str,
		int	sep
	)

char* split_token	(	char **	sp,
		int	sep
	)

char* trim_space_sep	(	char *	str,
		int	sep
	)

int xlate

(

char *

arg

)

Definition at line 2030 of file functions.c.

References is_integer(), and trim_space_sep().

{
        int temp;
        char *temp2;

        if(arg[0] == '#') {
                arg++;
                /* #- anything is false */
                if(arg[1] == '-') {
                        return 0;
                }
                if(is_integer(arg)) {
                        temp = atoi(arg);
                        if(temp == -1)
                                temp = 0;
                        return temp;
                }
                return 0;
        }
        temp2 = trim_space_sep(arg, ' ');
        if(!*temp2)
                return 0;
        if(is_integer(temp2))
                return atoi(temp2);
        return 1;
}

---