自学教程：C++ CHECKOP函数代码示例

voidprim_event_exists(PRIM_PROTOTYPE){    CHECKOP(1);    oper1 = POP();		/* str: eventID to look for */    if (oper1->type != PROG_STRING || !oper1->data.string)	abort_interp("Expected a non-null string eventid to search for.");    result = muf_event_exists(fr, oper1->data.string->data);    CLEAR(oper1);    PushInt(result);}

void prim_prettylock(PRIM_PROTOTYPE){    const char *ptr;    CHECKOP(1);    oper1 = POP();		/* lock: lock */    if (oper1->type != PROG_LOCK)	abort_interp("Invalid argument");    ptr = unparse_boolexp(ProgUID, oper1->data.lock, 1);    CHECKOFLOW(1);    CLEAR(oper1);    PushString(ptr);}

voidprim_lreverse(PRIM_PROTOTYPE){	int i;	CHECKOP(1);	oper1 = POP();	if (oper1->type != PROG_INTEGER)		abort_interp("Invalid argument type.");	tmp = oper1->data.number;	/* Depth on stack */	if (tmp < 0)		abort_interp("Argument must be positive.");	CHECKOP(tmp);	if (tmp > 0) {		for (i = 0; i < (tmp / 2); i++) {			temp2 = arg[*top - (tmp - i)];			arg[*top - (tmp - i)] = arg[*top - (i + 1)];			arg[*top - (i + 1)] = temp2;		}	}	CLEAR(oper1);	PushInt(tmp);}

voidprim_interp(PRIM_PROTOTYPE){	struct inst *oper1 = NULL; /* prevents re-entrancy issues! */	struct inst *oper2 = NULL; /* prevents re-entrancy issues! */	struct inst *oper3 = NULL; /* prevents re-entrancy issues! */	struct inst *rv=NULL;	char buf[BUFFER_LEN];	struct frame *tmpfr;	CHECKOP(3);	oper3 = POP();				/* string -- top stack argument */	oper2 = POP();				/* dbref  --  trigger */	oper1 = POP();				/* dbref  --  Program to run */	if (!valid_object(oper1) || Typeof(oper1->data.objref) != TYPE_PROGRAM)		abort_interp("Bad program reference. (1)");	if (!valid_object(oper2))		abort_interp("Bad object. (2)");	if ((mlev < 3) && !permissions(ProgUID, oper2->data.objref))		abort_interp("Permission denied.");	if (fr->level > 8)		abort_interp("Interp call loops not allowed.");	CHECKREMOTE(oper2->data.objref);	strcpyn(buf, sizeof(buf), match_args);	strcpyn(match_args, sizeof(match_args), oper3->data.string ? oper3->data.string->data : "");	tmpfr = interp(fr->descr, player, DBFETCH(player)->location, oper1->data.objref,				   oper2->data.objref, PREEMPT, STD_HARDUID, 0);	if (tmpfr) {		rv = interp_loop(player, oper1->data.objref, tmpfr, 1);	}	strcpyn(match_args, sizeof(match_args), buf);	CLEAR(oper3);	CLEAR(oper2);	CLEAR(oper1);	if (rv) {		if (rv->type < PROG_STRING) {			push(arg, top, rv->type, MIPSCAST(&rv->data.number));		} else {			push(arg, top, rv->type, MIPSCAST(rv->data.string));		}	} else {		PushNullStr;	}}

void prim_fread(PRIM_PROTOTYPE){  FILE *fh;  char *filename;  double offset;  char tempchr[2];  int result;  CHECKOP(2);  oper1 = POP();  oper2 = POP();  if (getuid() == 0 )     abort_interp("Muck is running under root privs, file prims disabled.");  if (mlev < LBOY) abort_interp("BOY primitive only.");    if(oper1->type != PROG_INTEGER)    abort_interp("Arguement 1 is not an integer.");  if(oper1->data.number < 0 ) abort_interp("Arguement 1 is a negative number.");  if(oper2->type != PROG_STRING) abort_interp("Arguement 2 is not a string.");  if(!oper2->data.string) abort_interp("Argueemnt 2 is a null string.");  offset = oper1->data.number;  filename = oper2->data.string->data;#ifdef SECURE_FILE_PRIMS  if (!(valid_name(filename)))      abort_interp( "Invalid file name.");  if ( strchr( filename, '$' ) == NULL )    filename = set_directory(filename);  else    filename = parse_token( filename );  if ( filename == NULL )    abort_interp( "Invalid shortcut used." );#endif  fh = fopen(filename, "r");  if (fh == NULL) { result = 0; } else {    fseek(fh, offset, SEEK_SET);    tempchr[0] = (char) fgetc(fh);    tempchr[1] = '/0';    fclose(fh);    sprintf(buf, "%s", tempchr);    result = 1;    if(tp_log_files)      log2filetime("logs/files", "#%d by %s FREAD: %s /n", program, unparse_object(player, player), oper2->data.string->data);    if ( tempchr[0] == EOF )      result = 0;  }  CLEAR(oper1);  CLEAR(oper2);  if( result )     PushString(buf);  else      PushNullStr;} 

voidprim_bitand(PRIM_PROTOTYPE){    CHECKOP(2);    oper1 = POP();    oper2 = POP();    if (!arith_type(oper2, oper1))        abort_interp("Invalid argument type");    result = oper2->data.number & oper1->data.number;    tmp = oper2->type;    CLEAR(oper1);    CLEAR(oper2);    push(arg, top, tmp, MIPSCAST & result);}

voidprim_logstatus(PRIM_PROTOTYPE){    CHECKOP(1);    oper1 = POP();    if (mlev < LARCH)        abort_interp("Archwizard primitive.");    if (oper1->type != PROG_STRING)        abort_interp("Non-string argument (1).");    if (oper1->data.string) {        strcpy(buf, oper1->data.string->data);        log_status("%s/r/n", buf);    }    CLEAR(oper1);}

void prim_online(PRIM_PROTOTYPE){    CHECKOP(0);    if (mlev < (tp_compatible_muf ? LM3 : LM2))	abort_interp(tp_compatible_muf ? "M3 prim" : "M2 prim");    result = pcount();    CHECKOFLOW(result + 1);    while (result) {	ref = pdbref(result--);	PushObject(ref);    }    result = pcount();    PushInt(result);}

void prim_nextdescr(PRIM_PROTOTYPE){    /* int -- int */    CHECKOP(1);    oper1 = POP();    if (mlev < LM3)	abort_interp("M3 prim");    if (oper1->type != PROG_INTEGER)	abort_interp("Argument not an integer (1)");    result = oper1->data.number;    result = pnextdescr(result);    CLEAR(oper1);    PushInt(result);}

void prim_awakep(PRIM_PROTOTYPE){    CHECKOP(1);    oper1 = POP();    if (!valid_object(oper1))	abort_interp("invalid argument");    ref = oper1->data.objref;    if (Typeof(ref) == TYPE_THING && (FLAGS(ref) & ZOMBIE))	ref = OWNER(ref);    if (Typeof(ref) != TYPE_PLAYER)	abort_interp("invalid argument");    result = online(ref);    PushInt(result);}

voidprim_atan(PRIM_PROTOTYPE){	CHECKOP(1);	oper1 = POP();	if (oper1->type != PROG_FLOAT)		abort_interp("Non-float argument. (1)");	if (!no_good(oper1->data.fnumber)) {		fresult = atan(oper1->data.fnumber);	} else {		fresult = H_PI;	}	CLEAR(oper1);	PushFloat(fresult);}

voidprim_atan2(PRIM_PROTOTYPE){	CHECKOP(2);	oper2 = POP();	oper1 = POP();	if (oper1->type != PROG_FLOAT)		abort_interp("Non-float argument. (1)");	if (oper2->type != PROG_FLOAT)		abort_interp("Non-float argument. (2)");	fresult = atan2(oper1->data.fnumber, oper2->data.fnumber);	CLEAR(oper1);	CLEAR(oper2);	PushFloat(fresult);}

voidprim_put(PRIM_PROTOTYPE){    CHECKOP(2);    oper1 = POP();    oper2 = POP();    if (oper1->type != PROG_INTEGER || oper1->data.number <= 0)	abort_interp("Operand not a positive integer.");    tmp = oper1->data.number;    EXPECT_WRITE_STACK(tmp);    CLEAR(&arg[*top - tmp]);    copyinst(oper2, &arg[*top - tmp]);    CLEAR(oper1);    CLEAR(oper2);}

voidprim_ftostr(PRIM_PROTOTYPE){	CHECKOP(1);	oper1 = POP();       if ( oper1->type == PROG_INTEGER )           { oper1->type = PROG_FLOAT;            oper1->data.fnumber = oper1->data.number;          }	if (oper1->type != PROG_FLOAT)		abort_interp("Non-float argument. (1)");	sprintf(buf, "%#g", oper1->data.fnumber);	CLEAR(oper1);	PushString(buf);}

voidprim_cancallp(PRIM_PROTOTYPE){    CHECKOP(2);    oper2 = POP();		/* string: public function name */    oper1 = POP();		/* dbref: Program dbref to check */    if (oper1->type != PROG_OBJECT)	abort_interp("Expected dbref argument. (1)");    if (!valid_object(oper1))	abort_interp("Invalid dbref (1)");    if (Typeof(oper1->data.objref) != TYPE_PROGRAM)	abort_interp("Object is not a MUF Program. (1)");    if (oper2->type != PROG_STRING)	abort_interp("Expected string argument. (2)");    if (!oper2->data.string)	abort_interp("Invalid Null string argument. (2)");    if (!(PROGRAM_CODE(oper1->data.objref))) {	struct line *tmpline;	tmpline = PROGRAM_FIRST(oper1->data.objref);	PROGRAM_SET_FIRST(oper1->data.objref,			  (struct line *) read_program(oper1->data.objref));	do_compile(-1, OWNER(oper1->data.objref), oper1->data.objref, 0);	free_prog_text(PROGRAM_FIRST(oper1->data.objref));	PROGRAM_SET_FIRST(oper1->data.objref, tmpline);    }    result = 0;    if (ProgMLevel(oper1->data.objref) > 0 &&	(mlev >= 4 || OWNER(oper1->data.objref) == ProgUID || Linkable(oper1->data.objref))	    ) {	struct publics *pbs;	pbs = PROGRAM_PUBS(oper1->data.objref);	while (pbs) {	    if (!strcasecmp(oper2->data.string->data, pbs->subname))		break;	    pbs = pbs->next;	}	if (pbs && mlev >= pbs->mlev)	    result = 1;    }    CHECKOFLOW(1);    CLEAR(oper1);    CLEAR(oper2);    PushInt(result);}

void prim_ispidp(PRIM_PROTOTYPE){    /* i -- i */    CHECKOP(1);    oper1 = POP();    if (oper1->type != PROG_INTEGER)	abort_interp("Non-integer argument (1)");    if (oper1->data.number == fr->pid) {	result = 1;    } else {        result = in_timequeue(oper1->data.number);    }    CLEAR(oper1);    PushInt(result);}

voidprim_at(PRIM_PROTOTYPE){    CHECKOP(1);    temp1 = *(oper1 = POP());    if ((temp1.type != PROG_VAR) && (temp1.type != PROG_LVAR))	abort_interp("Non-variable argument.");    if (temp1.data.number >= MAX_VAR || temp1.data.number < 0)        abort_interp("Variable number out of range.");    if (temp1.type == PROG_LVAR) {	copyinst(&(CurrVar[temp1.data.number]), &arg[(*top)++]);    } else {	copyinst(&(fr->variables[temp1.data.number]), &arg[(*top)++]);    }    CLEAR(&temp1);}

voidprim_floor(PRIM_PROTOTYPE){	CHECKOP(1);	oper1 = POP();	if (oper1->type != PROG_FLOAT)		abort_interp("Non-float argument. (1)");	if (!no_good(oper1->data.fnumber)) {		fresult = (float) floor((double) oper1->data.fnumber);	} else {		fresult = 0.0;		fr->error.error_flags.f_bounds = 1;	}	CLEAR(oper1);	PushFloat(fresult);}

voidprim_acos(PRIM_PROTOTYPE){	CHECKOP(1);	oper1 = POP();	if (oper1->type != PROG_FLOAT)		abort_interp("Non-float argument. (1)");	if ((oper1->data.fnumber >= -1.0) && (oper1->data.fnumber <= 1.0)) {		fresult = acos(oper1->data.fnumber);	} else {		fresult = 0.0;		fr->error.error_flags.nan = 1;	}	CLEAR(oper1);	PushFloat(fresult);}

voidprim_conboot(PRIM_PROTOTYPE){    /* int --  */    CHECKOP(1);    if (mlev < (tp_compatible_muf ? LMAGE : LARCH))	abort_interp(tp_compatible_muf ? "Mage prim" : "Arch prim");    oper1 = POP();    if (oper1->type != PROG_INTEGER)	abort_interp("Argument not an integer (1)");    result = oper1->data.number;    if ((result < 1) || (result > pcount()))	abort_interp("Invalid connection number (1)");    CLEAR(oper1);    pboot(result);}

voidprim_forpop(PRIM_PROTOTYPE){	CHECKOP(0);	if (!(fr->fors.top))		abort_interp("Internal error; FOR stack underflow.");	CLEAR(&fr->fors.st->cur);	CLEAR(&fr->fors.st->end);	if (fr->trys.st)		fr->trys.st->for_count--;	fr->fors.top--;	fr->fors.st = pop_for(fr->fors.st);}

voidprim_sysparm_array(PRIM_PROTOTYPE){    stk_array *nu;    int security = TUNE_MLEV(player);    CHECKOP(1);    oper1 = POP();		/* string: match pattern */    if (oper1->type != PROG_STRING)	abort_interp("Expected a string smatch pattern.");    nu = tune_parms_array(DoNullInd(oper1->data.string), security, fr->pinning);    CLEAR(oper1);    PushArrayRaw(nu);}

voidprim_ignore_del(PRIM_PROTOTYPE){    CHECKOP(2);    oper1 = POP();    oper2 = POP();    if (mlev < 3)	abort_interp("Permission Denied.");    if (!valid_object(oper1))	abort_interp("Invalid object. (2)");    if (!valid_object(oper2))	abort_interp("Invalid object. (1)");    ignore_remove_player(oper2->data.objref, oper1->data.objref);    CLEAR(oper1);    CLEAR(oper2);}

voidprim_setsysparm(PRIM_PROTOTYPE){	const char *oldvalue, *newvalue;	int security = TUNE_MLEV(player);	CHECKOP(2);	oper1 = POP();				/* string: new parameter value */	oper2 = POP();				/* string: parameter to tune */	if (mlev < 4)		abort_interp("Wizbit only primitive.");	if (force_level)		abort_interp("Cannot be forced.");	if (oper2->type != PROG_STRING)		abort_interp("Invalid argument. (1)");	if (!oper2->data.string)		abort_interp("Null string argument. (1)");	if (oper1->type != PROG_STRING)		abort_interp("Invalid argument. (2)");	oldvalue = tune_get_parmstring(oper2->data.string->data, security);	newvalue = oper1->data.string ? oper1->data.string->data : "";	result = tune_setparm(oper2->data.string->data, newvalue, security);	switch (result) {	case TUNESET_SUCCESS:		log_status("TUNED (MUF): %s(%d) tuned %s from '%s' to '%s'",				   NAME(player), player, oper2->data.string->data, oldvalue, newvalue);		break;	case TUNESET_UNKNOWN:		abort_interp("Unknown parameter. (1)");		break;	case TUNESET_SYNTAX:		abort_interp("Bad parameter syntax. (2)");		break;	case TUNESET_BADVAL:		abort_interp("Bad parameter value. (2)");		break;	case TUNESET_DENIED:		abort_interp("Permission denied. (1)");		break;	}	CLEAR(oper1);	CLEAR(oper2);}

voidprim_event_send(PRIM_PROTOTYPE){	struct frame* destfr;	stk_array *arr;	struct inst temp1;	CHECKOP(3);	oper3 = POP();				/* any: data to pass */	oper2 = POP();				/* string: event id */	oper1 = POP();				/* int: process id to send to */	if (mlev < 3)		abort_interp("Requires Mucker level 3 or better.");	if (oper1->type != PROG_INTEGER)		abort_interp("Expected an integer process id. (1)");	if (oper2->type != PROG_STRING)		abort_interp("Expected a string event id. (2)");	if (oper1->data.number == fr->pid)		destfr = fr;	else		destfr = timequeue_pid_frame(oper1->data.number);	if (destfr) {		arr = new_array_dictionary();		array_set_strkey(&arr, "data", oper3);		array_set_strkey_intval(&arr, "caller_pid", fr->pid);		array_set_strkey_intval(&arr, "descr", fr->descr);		array_set_strkey_refval(&arr, "caller_prog", program);		array_set_strkey_refval(&arr, "trigger", fr->trig);		array_set_strkey_refval(&arr, "prog_uid", ProgUID);		array_set_strkey_refval(&arr, "player", player);		temp1.type = PROG_ARRAY;		temp1.data.array = arr;		snprintf(buf, sizeof(buf), "USER.%.32s", DoNullInd(oper2->data.string));		muf_event_add(destfr, buf, &temp1, 0);		CLEAR(&temp1);	}	CLEAR(oper1);	CLEAR(oper2);	CLEAR(oper3);}

voidprim_strtof(PRIM_PROTOTYPE){	CHECKOP(1);	oper1 = POP();	if (oper1->type != PROG_STRING)		abort_interp("Non-string argument. (1)");	fresult = 0.0;	if (!oper1->data.string || !ifloat(oper1->data.string->data)) {		fresult = 0.0;		fr->error.error_flags.nan = 1;	} else {		sscanf(oper1->data.string->data, "%g", &fresult);	}	CLEAR(oper1);	PushFloat(fresult);}

voidprim_mod(PRIM_PROTOTYPE){	CHECKOP(2);	oper1 = POP();	oper2 = POP();	if ((!arith_type(oper2, oper1)) || (oper1->type == PROG_FLOAT) ||		(oper2->type == PROG_FLOAT)) abort_interp("Invalid argument type.");	if (oper1->data.number)		result = oper2->data.number % oper1->data.number;	else		result = 0;	tmp = oper2->type;	CLEAR(oper1);	CLEAR(oper2);	push(arg, top, tmp, MIPSCAST & result);}

voidprim_cos(PRIM_PROTOTYPE){	CHECKOP(1);	oper1 = POP();	if (oper1->type != PROG_FLOAT)		abort_interp("Non-float argument. (1)");	if (!no_good(oper1->data.fnumber)) {		fresult = cos(oper1->data.fnumber);	} else {		/* FIXME:  This should be NaN. */		fresult = 0.0;		fr->error.error_flags.f_bounds = 1;	}	CLEAR(oper1);	PushFloat(fresult);}

voidprim_sysparm_array(PRIM_PROTOTYPE){    stk_array *nu;    /* string */    CHECKOP(1);    oper1 = POP();    if (oper1->type != PROG_STRING)        abort_interp("Expected a string smatch pattern. (1)");    nu = tune_parms_array(DoNullInd(oper1->data.string), mlev);    CLEAR(oper1);    PushArrayRaw(nu);}

voidprim_ignoringp(PRIM_PROTOTYPE){    CHECKOP(2);    oper1 = POP();    oper2 = POP();    if (mlev < 3)	abort_interp("Permission Denied.");    if (!valid_object(oper1))	abort_interp("Invalid object. (2)");    if (!valid_object(oper2))	abort_interp("Invalid object. (1)");    result = ignore_is_ignoring(oper2->data.objref, oper1->data.objref);    CLEAR(oper1);    CLEAR(oper2);    PushInt(result);}