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

/* * Expand arithmetic expression. */static char *expari(char *p, int flag, struct worddest *dst){	char *q, *start;	arith_t result;	int begoff;	int quoted;	int adj;	quoted = *p++ == '"';	begoff = expdest - stackblock();	p = argstr(p, 0, NULL);	STPUTC('/0', expdest);	start = stackblock() + begoff;	q = grabstackstr(expdest);	result = arith(start);	ungrabstackstr(q, expdest);	start = stackblock() + begoff;	adj = start - expdest;	STADJUST(adj, expdest);	CHECKSTRSPACE((int)(DIGITS(result) + 1), expdest);	fmtstr(expdest, DIGITS(result), ARITH_FORMAT_STR, result);	adj = strlen(expdest);	STADJUST(adj, expdest);	if (!quoted)		reprocess(expdest - adj - stackblock(), flag, VSNORMAL, 0, dst);	return p;}

voidexpandhere(union node *arg, int fd){	herefd = fd;	expandarg(arg, NULL, 0);	xwrite(fd, stackblock(), expdest - stackblock());}

/* * Expand arithmetic expression. * Note that flag is not required as digits never require CTLESC characters. */static char *expari(char *p){	char *q, *start;	arith_t result;	int begoff;	int quoted;	int adj;	quoted = *p++ == '"';	begoff = expdest - stackblock();	p = argstr(p, 0);	removerecordregions(begoff);	STPUTC('/0', expdest);	start = stackblock() + begoff;	q = grabstackstr(expdest);	result = arith(start);	ungrabstackstr(q, expdest);	start = stackblock() + begoff;	adj = start - expdest;	STADJUST(adj, expdest);	CHECKSTRSPACE((int)(DIGITS(result) + 1), expdest);	fmtstr(expdest, DIGITS(result), ARITH_FORMAT_STR, result);	adj = strlen(expdest);	STADJUST(adj, expdest);	if (!quoted)		recordregion(begoff, expdest - stackblock(), 0);	return p;}

voidexpandhere(shinstance *psh, union node *arg, int fd){	psh->herefd = fd;	expandarg(psh, arg, (struct arglist *)NULL, 0);	xwrite(psh, fd, stackblock(psh), psh->expdest - stackblock(psh));}

intreadcmd(int argc, char **argv){	char **ap;	int backslash;	char c;	int rflag;	char *prompt;	char *p;	int status;	int i;	rflag = 0;	prompt = NULL;	while ((i = nextopt("p:r")) != '/0') {		if (i == 'p')			prompt = optionarg;		else			rflag = 1;	}	if (prompt && isatty(0)) {		out2str(prompt);#ifdef FLUSHERR		flushall();#endif	}	if (*(ap = argptr) == NULL)		sh_error("arg count");	status = 0;	backslash = 0;	STARTSTACKSTR(p);	for (;;) {		if (read(0, &c, 1) != 1) {			status = 1;			break;		}		if (c == '/0')			continue;		if (backslash) {			if (c == '/n')				goto resetbs;			STPUTC(CTLESC, p);			goto put;		}		if (!rflag && c == '//') {			backslash++;			continue;		}		if (c == '/n')			break;put:		STPUTC(c, p);resetbs:		backslash = 0;	}	STACKSTRNUL(p);	readcmd_handle_line(stackblock(), ap, p + 1 - (char *)stackblock());	return status;}

char *growstackstr(void){	int len = stackblocksize();	if (herefd >= 0 && len >= 1024) {		xwrite(herefd, stackblock(), len);		sstrnleft = len - 1;		return stackblock();	}	growstackblock();	sstrnleft = stackblocksize() - len - 1;	return stackblock() + len;}

/* * Expand arithmetic expression. * Note that flag is not required as digits never require CTLESC characters. */static char *expari(char *p){    char *q, *start;    arith_t result;    int begoff;    int quoted;    int c;    int nesting;    int adj;    quoted = *p++ == '"';    begoff = expdest - stackblock();    argstr(p, 0);    removerecordregions(begoff);    STPUTC('/0', expdest);    start = stackblock() + begoff;    q = grabstackstr(expdest);    result = arith(start);    ungrabstackstr(q, expdest);    start = stackblock() + begoff;    adj = start - expdest;    STADJUST(adj, expdest);    CHECKSTRSPACE((int)(DIGITS(result) + 1), expdest);    fmtstr(expdest, DIGITS(result), ARITH_FORMAT_STR, result);    adj = strlen(expdest);    STADJUST(adj, expdest);    if (!quoted)        recordregion(begoff, expdest - stackblock(), 0);    nesting = 1;    while (nesting > 0) {        c = *p++;        if (c == CTLESC)            p++;        else if (c == CTLARI)            nesting++;        else if (c == CTLENDARI)            nesting--;        else if (c == CTLVAR)            p++; /* ignore variable substitution byte */        else if (c == '/0')            return p - 1;    }    return p;}

/* * Perform expansions on an argument, placing the resulting list of arguments * in arglist.  Parameter expansion, command substitution and arithmetic * expansion are always performed; additional expansions can be requested * via flag (EXP_*). * The result is left in the stack string. * When arglist is NULL, perform here document expansion. * * When doing something that may cause this to be re-entered, make sure * the stack string is empty via grabstackstr() and do not assume expdest * remains valid. */voidexpandarg(union node *arg, struct arglist *arglist, int flag){	struct worddest exparg;	struct nodelist *argbackq;	if (fflag)		flag &= ~EXP_GLOB;	argbackq = arg->narg.backquote;	exparg.list = arglist;	exparg.state = WORD_IDLE;	STARTSTACKSTR(expdest);	argstr(arg->narg.text, &argbackq, flag, &exparg);	if (arglist == NULL) {		STACKSTRNUL(expdest);		return;			/* here document expanded */	}	if ((flag & EXP_SPLIT) == 0 || expdest != stackblock() ||	    exparg.state == WORD_QUOTEMARK) {		STPUTC('/0', expdest);		if (flag & EXP_SPLIT) {			if (flag & EXP_GLOB)				expandmeta(grabstackstr(expdest), exparg.list);			else				appendarglist(exparg.list, grabstackstr(expdest));		}	}	if ((flag & EXP_SPLIT) == 0)		appendarglist(arglist, grabstackstr(expdest));}

static intsubevalvar_misc(char *p, const char *var, int subtype, int startloc,  int varflags){	char *startp;	struct nodelist *saveargbackq = argbackq;	int amount;	argstr(p, EXP_TILDE, NULL);	STACKSTRNUL(expdest);	argbackq = saveargbackq;	startp = stackblock() + startloc;	switch (subtype) {	case VSASSIGN:		setvar(var, startp, 0);		amount = startp - expdest;		STADJUST(amount, expdest);		return 1;	case VSQUESTION:		if (*p != CTLENDVAR) {			outfmt(out2, "%s/n", startp);			error((char *)NULL);		}		error("%.*s: parameter %snot set", (int)(p - var - 1),		      var, (varflags & VSNUL) ? "null or " : "");		return 0;	default:		abort();	}}

intechocmd(int argc, char **argv){	int nonl = 0;	struct output *outs = out1;	if (!*++argv)		goto end;	if (equal(*argv, "-n")) {		nonl = ~nonl;		if (!*++argv)			goto end;	}	do {		int c;		nonl += conv_escape_str(*argv);		outstr(stackblock(), outs);		if (nonl > 0)			break;		c = ' ';		if (!*++argv) {end:			if (nonl) {				break;			}			c = '/n';		}		outc(c, outs);	} while (*argv);	return 0;}

char *padvance(const char **path, const char *name){	const char *p, *start;	char *q;	int len;	if (*path == NULL)		return NULL;	start = *path;	for (p = start; *p && *p != ':' && *p != '%'; p++)		; /* nothing */	len = p - start + strlen(name) + 2;	/* "2" is for '/' and '/0' */	while (stackblocksize() < len)		growstackblock();	q = stackblock();	if (p != start) {		memcpy(q, start, p - start);		q += p - start;		*q++ = '/';	}	strcpy(q, name);	pathopt = NULL;	if (*p == '%') {		pathopt = ++p;		while (*p && *p != ':')  p++;	}	if (*p == ':')		*path = p + 1;	else		*path = NULL;	return stalloc(len);}

char *makestrspace(int min, char *p){	int len;	len = p - stackblock();	return (growstrstackblock(len, min));}

char *makestrspace(void){	int len = stackblocksize() - sstrnleft;	growstackblock();	sstrnleft = stackblocksize() - len;	return stackblock() + len;}

/* * Expand arithmetic expression.  Backup to start of expression, * evaluate, place result in (backed up) result, adjust string position. */voidexpari(int flag){	char *p, *start;	intmax_t result;	int adjustment;	int begoff;	int quotes = flag & (EXP_FULL | EXP_CASE);	int quoted;	/*	ifsfree(); */	/*	 * This routine is slightly over-complicated for	 * efficiency.  First we make sure there is	 * enough space for the result, which may be bigger	 * than the expression if we add exponentation.  Next we	 * scan backwards looking for the start of arithmetic.  If the	 * next previous character is a CTLESC character, then we	 * have to rescan starting from the beginning since CTLESC	 * characters have to be processed left to right.	 *//* SPACE_NEEDED is enough for all digits, plus possible "-", plus 2 (why?) */#define SPACE_NEEDED ((sizeof(intmax_t) * CHAR_BIT + 2) / 3 + 1 + 2)	CHECKSTRSPACE((int)(SPACE_NEEDED - 2), expdest);	USTPUTC('/0', expdest);	start = stackblock();	p = expdest - 1;	while (*p != CTLARI && p >= start)		--p;	if (*p != CTLARI)		error("missing CTLARI (shouldn't happen)");	if (p > start && *(p-1) == CTLESC)		for (p = start; *p != CTLARI; p++)			if (*p == CTLESC)				p++;	if (p[1] == '"')		quoted=1;	else		quoted=0;	begoff = p - start;	removerecordregions(begoff);	if (quotes)		rmescapes(p+2);	result = arith(p+2);	fmtstr(p, SPACE_NEEDED, "%"PRIdMAX, result);	while (*p++)		;	if (quoted == 0)		recordregion(begoff, p - 1 - start, 0);	adjustment = expdest - p + 1;	STADJUST(-adjustment, expdest);}

/* * Expand arithmetic expression.  Backup to start of expression, * evaluate, place result in (backed up) result, adjust string position. */voidexpari(shinstance *psh, int flag){	char *p, *start;	int result;	int begoff;	int quotes = flag & (EXP_FULL | EXP_CASE);	int quoted;	/*	ifsfree(); */	/*	 * This routine is slightly over-complicated for	 * efficiency.  First we make sure there is	 * enough space for the result, which may be bigger	 * than the expression if we add exponentation.  Next we	 * scan backwards looking for the start of arithmetic.  If the	 * next previous character is a CTLESC character, then we	 * have to rescan starting from the beginning since CTLESC	 * characters have to be processed left to right.	 */#if INT_MAX / 1000000000 >= 10 || INT_MIN / 1000000000 <= -10#error "integers with more than 10 digits are not supported"#endif	CHECKSTRSPACE(psh, 12 - 2, psh->expdest);	USTPUTC(psh, '/0', psh->expdest);	start = stackblock(psh);	p = psh->expdest - 1;	while (*p != CTLARI && p >= start)		--p;	if (*p != CTLARI)		error(psh, "missing CTLARI (shouldn't happen)");	if (p > start && *(p-1) == CTLESC)		for (p = start; *p != CTLARI; p++)			if (*p == CTLESC)				p++;	if (p[1] == '"')		quoted=1;	else		quoted=0;	begoff = (int)(p - start);	removerecordregions(psh, begoff);	if (quotes)		rmescapes(psh, p+2);	result = arith(psh, p+2);	fmtstr(p, 12, "%d", result);	while (*p++)		;	if (quoted == 0)		recordregion(psh, begoff, (int)(p - 1 - start), 0);	result = (int)(psh->expdest - p + 1);	STADJUST(psh, -result, psh->expdest);}

/** handle one line of the read command. *  more fields than variables -> remainder shall be part of last variable. *  less fields than variables -> remaining variables unset. * *  @param line complete line of input *  @param ap argument (variable) list *  @param len length of line including trailing '/0' */static voidreadcmd_handle_line(char *s, char **ap){	struct arglist arglist;	struct strlist *sl;	char *backup;	char *line;	/* ifsbreakup will fiddle with stack region... */	line = stackblock();	s = grabstackstr(s);	/* need a copy, so that delimiters aren't lost	 * in case there are more fields than variables */	backup = sstrdup(line);	arglist.lastp = &arglist.list;		ifsbreakup(s, &arglist);	*arglist.lastp = NULL;	ifsfree();	sl = arglist.list;	do {		if (!sl) {			/* nullify remaining arguments */			do {				setvar(*ap, nullstr, 0);			} while (*++ap);			return;		}		/* remaining fields present, but no variables left. */		if (!ap[1] && sl->next) {			size_t offset;			char *remainder;			/* FIXME little bit hacky, assuming that ifsbreakup 			 * will not modify the length of the string */			offset = sl->text - s;			remainder = backup + offset;			rmescapes(remainder);			setvar(*ap, remainder, 0);			return;		}				/* set variable to field */		rmescapes(sl->text);		setvar(*ap, sl->text, 0);		sl = sl->next;	} while (*++ap);}

/* * Expand arithmetic expression.  Backup to start of expression, * evaluate, place result in (backed up) result, adjust string position. */voidexpari(int flag){	char *p, *q, *start;	arith_t result;	int begoff;	int quotes = flag & (EXP_FULL | EXP_CASE | EXP_REDIR);	int quoted;	/*	 * This routine is slightly over-complicated for	 * efficiency.  First we make sure there is	 * enough space for the result, which may be bigger	 * than the expression.  Next we	 * scan backwards looking for the start of arithmetic.  If the	 * next previous character is a CTLESC character, then we	 * have to rescan starting from the beginning since CTLESC	 * characters have to be processed left to right.	 */	CHECKSTRSPACE(DIGITS(result) - 2, expdest);	USTPUTC('/0', expdest);	start = stackblock();	p = expdest - 2;	while (p >= start && *p != CTLARI)		--p;	if (p < start || *p != CTLARI)		error("missing CTLARI (shouldn't happen)");	if (p > start && *(p - 1) == CTLESC)		for (p = start; *p != CTLARI; p++)			if (*p == CTLESC)				p++;	if (p[1] == '"')		quoted=1;	else		quoted=0;	begoff = p - start;	removerecordregions(begoff);	if (quotes)		rmescapes(p+2);	q = grabstackstr(expdest);	result = arith(p+2);	ungrabstackstr(q, expdest);	fmtstr(p, DIGITS(result), ARITH_FORMAT_STR, result);	while (*p++)		;	if (quoted == 0)		recordregion(begoff, p - 1 - start, 0);	result = expdest - p + 1;	STADJUST(-result, expdest);}

char *single_quote(const char *s) {	char *p;	STARTSTACKSTR(p);	do {		char *q;		size_t len;		len = strchrnul(s, '/'') - s;		q = p = makestrspace(len + 3, p);		*q++ = '/'';		q = mempcpy(q, s, len);		*q++ = '/'';		s += len;		STADJUST(q - p, p);		len = strspn(s, "'");		if (!len)			break;		q = p = makestrspace(len + 3, p);		*q++ = '"';		q = mempcpy(q, s, len);		*q++ = '"';		s += len;		STADJUST(q - p, p);	} while (*s);	USTPUTC(0, p);	return stackblock();}

static char *nextword(char c, int flag, char *p, struct worddest *dst){	int is_ws;	is_ws = c == '/t' || c == '/n' || c == ' ';	if (p != stackblock() || (is_ws ? dst->state == WORD_QUOTEMARK :	    dst->state != WORD_WS_DELIMITED) || c == '/0') {		STPUTC('/0', p);		if (flag & EXP_GLOB)			expandmeta(grabstackstr(p), dst->list);		else			appendarglist(dst->list, grabstackstr(p));		dst->state = is_ws ? WORD_WS_DELIMITED : WORD_IDLE;	} else if (!is_ws && dst->state == WORD_WS_DELIMITED)		dst->state = WORD_IDLE;	/* Reserve space while the stack string is empty. */	appendarglist(dst->list, NULL);	dst->list->count--;	STARTSTACKSTR(p);	return p;}

char *single_quote(const char *s) {	char *p;	startstackstr(&p);	do {		char *q;		size_t len;		len = strchrnul(s, '/'') - s;		q = p = makestrspace(len + 3, p);		*q++ = '/'';		q = (char *)mempcpy(q, s, len);		*q++ = '/'';		s += len;		stadjust(q - p, &p);		len = strspn(s, "'");		if (!len)			break;		q = p = makestrspace(len + 3, p);		*q++ = '"';		q = (char *)mempcpy(q, s, len);		*q++ = '"';		s += len;		stadjust(q - p, &p);	} while (*s);	ustputc(0, &p);	return stackblock();}

static voidreprocess(int startloc, int flag, int subtype, int quoted,    struct worddest *dst){	static char *buf = NULL;	static size_t buflen = 0;	char *startp;	size_t len, zpos, zlen;	startp = stackblock() + startloc;	len = expdest - startp;	if (len >= SIZE_MAX / 2)		abort();	INTOFF;	if (len >= buflen) {		ckfree(buf);		buf = NULL;	}	if (buflen < 128)		buflen = 128;	while (len >= buflen)		buflen <<= 1;	if (buf == NULL)		buf = ckmalloc(buflen);	INTON;	memcpy(buf, startp, len);	buf[len] = '/0';	STADJUST(-len, expdest);	for (zpos = 0;;) {		zlen = strlen(buf + zpos);		strtodest(buf + zpos, flag, subtype, quoted, dst);		zpos += zlen + 1;		if (zpos == len + 1)			break;		if (flag & EXP_SPLIT && (quoted || (zlen > 0 && zpos < len)))			NEXTWORD('/0', flag, expdest, dst);	}}

/* * Perform command substitution. */static voidexpbackq(union node *cmd, int quoted, int flag){	struct backcmd in;	int i;	char buf[128];	char *p;	char *dest = expdest;	struct ifsregion saveifs, *savelastp;	struct nodelist *saveargbackq;	char lastc;	int startloc = dest - stackblock();	char const *syntax = quoted? DQSYNTAX : BASESYNTAX;	int quotes = flag & (EXP_FULL | EXP_CASE);	size_t nnl;	INTOFF;	saveifs = ifsfirst;	savelastp = ifslastp;	saveargbackq = argbackq;	p = grabstackstr(dest);	evalbackcmd(cmd, &in);	ungrabstackstr(p, dest);	ifsfirst = saveifs;	ifslastp = savelastp;	argbackq = saveargbackq;	p = in.buf;	lastc = '/0';	nnl = 0;	/* Don't copy trailing newlines */	for (;;) {		if (--in.nleft < 0) {			if (in.fd < 0)				break;			while ((i = read(in.fd, buf, sizeof buf)) < 0 && errno == EINTR);			TRACE(("expbackq: read returns %d/n", i));			if (i <= 0)				break;			p = buf;			in.nleft = i - 1;		}		lastc = *p++;		if (lastc != '/0') {			if (lastc == '/n') {				nnl++;			} else {				CHECKSTRSPACE(nnl + 2, dest);				while (nnl > 0) {					nnl--;					USTPUTC('/n', dest);				}				if (quotes && syntax[(int)lastc] == CCTL)					USTPUTC(CTLESC, dest);				USTPUTC(lastc, dest);			}		}	}	if (in.fd >= 0)		close(in.fd);	if (in.buf)		ckfree(in.buf);	if (in.jp)		exitstatus = waitforjob(in.jp, (int *)NULL);	if (quoted == 0)		recordregion(startloc, dest - stackblock(), 0);	TRACE(("expbackq: size=%td: /"%.*s/"/n",		((dest - stackblock()) - startloc),		(int)((dest - stackblock()) - startloc),		stackblock() + startloc));	expdest = dest;	INTON;}

static intsubevalvar(char *p, char *str, int strloc, int subtype, int startloc,  int varflags, int quotes){	char *startp;	char *loc = NULL;	char *q;	int c = 0;	struct nodelist *saveargbackq = argbackq;	int amount;	argstr(p, (subtype == VSTRIMLEFT || subtype == VSTRIMLEFTMAX ||	    subtype == VSTRIMRIGHT || subtype == VSTRIMRIGHTMAX ?	    EXP_CASE : 0) | EXP_TILDE);	STACKSTRNUL(expdest);	argbackq = saveargbackq;	startp = stackblock() + startloc;	if (str == NULL)	    str = stackblock() + strloc;	switch (subtype) {	case VSASSIGN:		setvar(str, startp, 0);		amount = startp - expdest;		STADJUST(amount, expdest);		varflags &= ~VSNUL;		return 1;	case VSQUESTION:		if (*p != CTLENDVAR) {			outfmt(out2, "%s/n", startp);			error((char *)NULL);		}		error("%.*s: parameter %snot set", (int)(p - str - 1),		      str, (varflags & VSNUL) ? "null or " : "");		return 0;	case VSTRIMLEFT:		for (loc = startp; loc < str; loc++) {			c = *loc;			*loc = '/0';			if (patmatch(str, startp, quotes)) {				*loc = c;				recordleft(str, loc, startp);				return 1;			}			*loc = c;			if (quotes && *loc == CTLESC)				loc++;		}		return 0;	case VSTRIMLEFTMAX:		for (loc = str - 1; loc >= startp;) {			c = *loc;			*loc = '/0';			if (patmatch(str, startp, quotes)) {				*loc = c;				recordleft(str, loc, startp);				return 1;			}			*loc = c;			loc--;			if (quotes && loc > startp && *(loc - 1) == CTLESC) {				for (q = startp; q < loc; q++)					if (*q == CTLESC)						q++;				if (q > loc)					loc--;			}		}		return 0;	case VSTRIMRIGHT:		for (loc = str - 1; loc >= startp;) {			if (patmatch(str, loc, quotes)) {				amount = loc - expdest;				STADJUST(amount, expdest);				return 1;			}			loc--;			if (quotes && loc > startp && *(loc - 1) == CTLESC) {				for (q = startp; q < loc; q++)					if (*q == CTLESC)						q++;				if (q > loc)					loc--;			}		}		return 0;	case VSTRIMRIGHTMAX:		for (loc = startp; loc < str - 1; loc++) {			if (patmatch(str, loc, quotes)) {				amount = loc - expdest;				STADJUST(amount, expdest);				return 1;			}			if (quotes && *loc == CTLESC)				loc++;//.........这里部分代码省略.........

/* * Perform parameter expansion, command substitution and arithmetic * expansion, and tilde expansion if requested via EXP_TILDE/EXP_VARTILDE. * Processing ends at a CTLENDVAR or CTLENDARI character as well as '/0'. * This is used to expand word in ${var+word} etc. * If EXP_FULL or EXP_CASE are set, keep and/or generate CTLESC * characters to allow for further processing. * If EXP_FULL is set, also preserve CTLQUOTEMARK characters. */static char *argstr(char *p, int flag){	char c;	int quotes = flag & (EXP_FULL | EXP_CASE);	/* do CTLESC */	int firsteq = 1;	int split_lit;	int lit_quoted;	split_lit = flag & EXP_SPLIT_LIT;	lit_quoted = flag & EXP_LIT_QUOTED;	flag &= ~(EXP_SPLIT_LIT | EXP_LIT_QUOTED);	if (*p == '~' && (flag & (EXP_TILDE | EXP_VARTILDE)))		p = exptilde(p, flag);	for (;;) {		CHECKSTRSPACE(2, expdest);		switch (c = *p++) {		case '/0':			return (p - 1);		case CTLENDVAR:		case CTLENDARI:			return (p);		case CTLQUOTEMARK:			lit_quoted = 1;			/* "[email
C++ staff函数代码示例
C++ stack_top函数代码示例