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

void AGOSEngine_PN::opn_opcode52() {	int32 mode = varval();	if (mode == 1) {		setWindowImage(mode, varval(), true);	} else {		setWindowImageEx(mode, varval());	}	setScriptReturn(true);}

/*ARGSUSED*/voiddochngd(Char **v, struct command *c){    Char *cp;    struct directory *dp;    int dflag = skipargs(&v, "plvn", "[-|<dir>]");    USE(c);    printd = 0;    cp = (dflag & DIR_OLD) ? varval(STRowd) : *v;    if (cp == NULL) {	if (!cdtohome)	    stderror(ERR_NAME | ERR_TOOFEW);	else if ((cp = varval(STRhome)) == STRNULL || *cp == 0)	    stderror(ERR_NAME | ERR_NOHOMEDIR);	if (chdir(short2str(cp)) < 0)	    stderror(ERR_NAME | ERR_CANTCHANGE);	cp = Strsave(cp);    }    else if ((dflag & DIR_OLD) == 0 && v[1] != NULL) {	stderror(ERR_NAME | ERR_TOOMANY);	/* NOTREACHED */	return;    }    else if ((dp = dfind(cp)) != 0) {	char   *tmp;	printd = 1;	if (chdir(tmp = short2str(dp->di_name)) < 0)	    stderror(ERR_SYSTEM, tmp, strerror(errno));	dcwd->di_prev->di_next = dcwd->di_next;	dcwd->di_next->di_prev = dcwd->di_prev;	dfree(dcwd);	dnewcwd(dp, dflag);	return;    }    else	if ((cp = dfollow(cp, dflag & DIR_OLD)) == NULL)	    return;    dp = xcalloc(sizeof(struct directory), 1);    dp->di_name = cp;    dp->di_count = 0;    dp->di_next = dcwd->di_next;    dp->di_prev = dcwd->di_prev;    dp->di_prev->di_next = dp;    dp->di_next->di_prev = dp;    dfree(dcwd);    dnewcwd(dp, dflag);}

int AGOSEngine_PN::setposition(int process, int line) {	uint8 *ourptr;	int np;	int ct;	ourptr = _dataBase + getlong(_quickptr[6] + 3 * process);	np = *ourptr++;	for (ct = 0; ct < line; ++ct) {		ourptr += (127 & *ourptr);	}	while (true) {		_linebase = ourptr;		_linct = (127 & *ourptr) - 1;		if (*ourptr++ <= 127)			break;		ct = varval();		if (ct == (int)_variableArray[1])			break;		ourptr += _linct - 1;		line++;	}	_linembr = line;	_procnum = process;	_variableArray[0] = process;	_workptr = ourptr;	return np;}

char *fix_path_for_child(void) {	char *ptr;	Char *vp;	char *pathstr;	char *oldpath;	long len;	vp = varval(STRNTlamepathfix);	if (vp != STRNULL) {		len = GetEnvironmentVariable("PATH",NULL,0);		oldpath = heap_alloc(len+1);		pathstr = heap_alloc(len+1);		len = GetEnvironmentVariable("PATH",oldpath,len+1);		memcpy(pathstr,oldpath,len);		ptr = pathstr;		while(*ptr) {			if (*ptr == '/')				*ptr = '//';			ptr++;		}		SetEnvironmentVariable("PATH",pathstr);		heap_free(pathstr);		return oldpath; //freed in restore_path;	}	else		return NULL;}

void AGOSEngine_PN::opn_opcode31() {	int a, slot = 0;	Common::String bf;	if ((a = varval()) > 2) {		setScriptReturn(false);		return;	}	switch (a) {		case 0:			getFilename();			slot = matchSaveGame(_saveFile, countSaveGames());			bf = genSaveName(slot);			break;		case 1:			bf = "pn.sav";			break;		case 2:			// NOTE: Is this case ever used?			error("opn_opcode31: case 2");			break;	}	if (slot == -1) {		setScriptReturn(false);	} else {		a = loadFile(bf);		if (a)			setScriptReturn(badload(a));		else			setScriptReturn(true);	}}

std::string path::expandvars(const std::string &path) {    std::string new_path(path);    if(new_path.find('$') == std::string::npos) {        return new_path;    }    pcrecpp::StringPiece path_re(new_path);    pcrecpp::RE expandvars_re(".*//$(//w+|//{[^}]*//})");    int offset = 0;    std::string _;    std::string varname;    while(expandvars_re.Consume(&path_re, &varname)) {        int varname_size = varname.size();        if(varname.find('{') == 0 && varname.find('}') == varname.size() - 1) {            varname = varname.substr(1, varname.length() - 2);        }        char *_varval = getenv(varname.c_str());        if(_varval != NULL) {            std::string varval(_varval);            offset = new_path.size() - path_re.size();            std::string tail(new_path.substr(offset));            new_path = new_path.substr(0, offset - varname_size - 1) + varval;            offset = new_path.size();            new_path += tail;        } else {            offset = new_path.size() - path_re.size();        }    }    return new_path;}

char * forward_slash_get_cwd(char * path, int maxlen) {	char *ptemp;	Char *vp;	int rc ;		if ((path == NULL) || (maxlen == 0)) {		path = &defcwd[0];		maxlen = MAX_PATH;	}	rc = GetCurrentDirectory(maxlen,path);	if (rc > maxlen) {		errno = ERANGE;		return NULL;	}	vp = varval(STRNTcaseifypwd);	if (vp != STRNULL) {		caseify_pwd(path);	}	ptemp=path;	path_slashify(ptemp);	return path;}

void AGOSEngine_PN::opn_opcode29() {	popstack(varval());	// Jump back to the last doline indicated by the top stackframe.	// The -1 tells it to simply go on with its business.	_dolineReturnVal = -1;	_tagOfActiveDoline = _stackbase->tagOfParentDoline;}

/* * Karl Kleinpaste, 18 Jan 1984. * Added period_cmd(), which executes the alias "periodic" every * $tperiod minutes.  Useful for occasional checking of msgs and such. */voidperiod_cmd(void){    Char *vp;    time_t  t, interval;    pintr_disabled++;    cleanup_push(&pintr_disabled, disabled_cleanup);    if (periodic_active) {	/* an error must have been caught */	aliasrun(2, STRunalias, STRperiodic);	xprintf("%s", CGETS(22, 6, "Faulty alias 'periodic' removed./n"));	goto leave;    }    periodic_active = 1;    if (!whyles && adrof1(STRperiodic, &aliases)) {	vp = varval(STRtperiod);	if (vp == STRNULL) {	    aliasrun(1, STRperiodic, NULL);	    goto leave;	}	interval = getn(vp);	(void) time(&t);	if (t - t_period >= interval * 60) {	    t_period = t;	    aliasrun(1, STRperiodic, NULL);	}    }leave:    periodic_active = 0;    cleanup_until(&pintr_disabled);}

void AGOSEngine_PN::opn_opcode12() {	char bf[8];	int a = 0;	sprintf(bf,"%d", varval());	while (bf[a])		pcf(bf[a++]);	setScriptReturn(true);}

void AGOSEngine_PN::opn_opcode38() {	_noScanFlag = 1;	clearInputLine();	writeval(_workptr, _keyPressed.ascii);	_keyPressed.reset();	_noScanFlag = 0;	varval();	setScriptReturn(true);}

static voiddset(Char *dp){    /*     * Don't call set() directly cause if the directory contains ` or     * other junk characters glob will fail.      */    setcopy(STRowd, varval(STRcwd), VAR_READWRITE|VAR_NOGLOB);    setcopy(STRcwd, dp, VAR_READWRITE|VAR_NOGLOB);    tsetenv(STRPWD, dp);}

int AGOSEngine_PN::doline(int needsave) {	assert(!_stackbase == !needsave);	int x;	int myTag = ++_tagOfActiveDoline;	// Obtain a unique tag for this doline invocation	_dolineReturnVal = 0;	if (_stackbase && needsave)		_stackbase->tagOfParentDoline = myTag;	do {		_linct = ((*_linebase) & 127) - 1;		_workptr = _linebase + 1;		if (*_linebase > 127) {			x = varval();			if (x != (int)_variableArray[1])				goto skipln;		}		do {			x = doaction();			if (_dolineReturnVal != 0) {				if (_tagOfActiveDoline != myTag)					return 0;				x = _dolineReturnVal;				_dolineReturnVal = 0;				if (x > 0) {					if (x != 3)						dumpstack();					// Restore the active jmpbuf to its previous value,					// then return _dolineReturnVal-1 (will be 2-1=1 or 1-1=0).					_tagOfActiveDoline = myTag - 1;					return (x - 1);				}			}		} while (x && !shouldQuit());skipln:		_linebase += 127 & *_linebase;		_linembr++;	} while (!shouldQuit());	return 0;}

void AGOSEngine_PN::opn_opcode63() {	int a = readfromline();	switch (a) {		case 65:			setScriptReturn(inventoryOn(varval()));			break;		case 64:			setScriptReturn((_videoLockOut & 0x10) != 0);			break;		case 63:			setScriptReturn(inventoryOff());			break;		default:			error("opn_opcode63: unknown code %d", a);	}}

voidloaddirs(Char *fname){    static Char *loaddirs_cmd[] = { STRsource, NULL, NULL };    bequiet = 1;    cleanup_push(&bequiet, bequiet_cleanup);    if (fname)	loaddirs_cmd[1] = fname;    else if ((fname = varval(STRdirsfile)) != STRNULL)	loaddirs_cmd[1] = fname;    else	loaddirs_cmd[1] = STRtildotdirs;    dosource(loaddirs_cmd, NULL);    cleanup_until(&bequiet);}

/*ARGSUSED*/voiddopopd(Char **v, struct command *c){    Char *cp;    struct directory *dp, *p = NULL;    int dflag = skipargs(&v, "plvn", " [-|+<n>]");    USE(c);    printd = 1;    cp = (dflag & DIR_OLD) ? varval(STRowd) : *v;    if (cp == NULL)	dp = dcwd;    else if ((dflag & DIR_OLD) == 0 && v[1] != NULL) {	stderror(ERR_NAME | ERR_TOOMANY);	/* NOTREACHED */	return;    }    else if ((dp = dfind(cp)) == 0)	stderror(ERR_NAME | ERR_BADDIR);    if (dp->di_prev == &dhead && dp->di_next == &dhead)	stderror(ERR_NAME | ERR_EMPTY);    if (dp == dcwd) {	char   *tmp;	if ((p = dp->di_prev) == &dhead)	    p = dhead.di_prev;	if (chdir(tmp = short2str(p->di_name)) < 0)	    stderror(ERR_SYSTEM, tmp, strerror(errno));    }    dp->di_prev->di_next = dp->di_next;    dp->di_next->di_prev = dp->di_prev;    dfree(dp);    if (dp == dcwd) {        dnewcwd(p, dflag);    }    else {	printdirs(dflag);    }}

/* Returns a newly allocated string, old or NULL */Char *globequal(Char *old){    int     dig;    const Char *dir;    Char    *b;    /*     * kfk - 17 Jan 1984 - stack hack allows user to get at arbitrary dir names     * in stack. PWP: let =foobar pass through (for X windows)     */    if (old[1] == '-' && (old[2] == '/0' || old[2] == '/')) {	/* =- */	const Char *olddir = varval (STRowd);	if (olddir && *olddir &&	    !dcwd->di_next->di_name && !dcwd->di_prev->di_name)	    return Strspl(olddir, &old[2]);	dig = -1;	b = &old[2];    }    else if (Isdigit(old[1])) {	/* =<number> */	dig = old[1] - '0';	for (b = &old[2]; Isdigit(*b); b++)	    dig = dig * 10 + (*b - '0');	if (*b != '/0' && *b != '/')	    /* =<number>foobar */	    return old;    }    else	/* =foobar */	return old;    dir = getstakd(dig);    if (dir == NULL)	return NULL;    return Strspl(dir, b);}