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

static int tsize( DCB_TYPEDEF orig ){    unsigned int n, total ;    switch ( orig.BaseType[0] )    {        case TYPE_ARRAY:            return orig.Count[0] * tsize( treduce( orig ) ) ;        case TYPE_POINTER:        case TYPE_STRING:        case TYPE_DWORD:        case TYPE_FLOAT:        case TYPE_INT:            return 4 ;        case TYPE_WORD:        case TYPE_SHORT:            return 2 ;        case TYPE_BYTE:        case TYPE_SBYTE:        case TYPE_CHAR:            return 1 ;        case TYPE_STRUCT:            total = 0 ;            for ( n = 0; n < dcb.varspace[orig.Members].NVars; n++ )                total += tsize( dcb.varspace_vars[orig.Members][n].Type ) ;            return total ;        default:            return 0 ;    }}

voidsqrt(int p2) {#ifndef NEQN	float nps;	nps = (int)(EFFPS(((eht[p2]*9)/10+(resolution/POINT-1))/(resolution/POINT)));#endif /* NEQN */	yyval.token = p2;#ifndef NEQN	eht[yyval.token] = VERT(EM(1.2, nps));	if(dbg)printf("./tsqrt: S%d <- S%d;b=%g, h=%g/n", 		yyval.token, p2, ebase[yyval.token], eht[yyval.token]);	if (ital(rfont[yyval.token]))		printf(".as %d //|/n", yyval.token);#endif /* NEQN */	nrwid(p2, ps, p2);#ifndef NEQN	printf(".ds %d //v'%gp'//s%s//v'-.2m'//(sr//l'//n(%du//(rn'//v'.2m'//s%s", 		yyval.token, ebase[p2], tsize(nps), p2, tsize(ps));	printf("//v'%gp'//h'-//n(%du'//*(%d/n", -ebase[p2], p2, p2);	lfont[yyval.token] = ROM;#else /* NEQN */	printf(".ds %d //v'%du'//e//L'%du'//l'//n(%du'",		p2, ebase[p2], -eht[p2], p2);	printf("//v'%du'//h'-//n(%du'//*(%d/n", eht[p2]-ebase[p2], p2, p2);	eht[p2] += VERT(1);	if(dbg)printf("./tsqrt: S%d <- S%d;b=%d, h=%d/n", 		p2, p2, ebase[p2], eht[p2]);#endif /* NEQN */}

/* setup struct parameter * push the registers out to memory * used by bfcode() */static voidparam_struct(struct symtab *sym, int *regp){	int reg = *regp;	NODE *p, *q;	int navail;	int sz;	int off;	int num;	int i;	navail = nargregs - (reg - A0);	sz = tsize(sym->stype, sym->sdf, sym->sap) / SZINT;	off = ARGINIT/SZINT + (reg - A0);	num = sz > navail ? navail : sz;	for (i = 0; i < num; i++) {		q = block(REG, NIL, NIL, INT, 0, 0);		q->n_rval = reg++;		p = block(REG, NIL, NIL, INT, 0, 0);		p->n_rval = FP;		p = block(PLUS, p, bcon(4*off++), INT, 0, 0);		p = block(UMUL, p, NIL, INT, 0, 0);		p = buildtree(ASSIGN, p, q);		ecomp(p);	}	*regp = reg;}

efcode(){	/* code for the end of a function */	if( strftn ){  /* copy output (in r0) to caller */		register struct symtab *p;		register int stlab;		register int count;		int size;		p = &stab[curftn];		deflab( retlab );		stlab = getlab();		printf( "	mov	$L%d,r1/n", stlab );		size = tsize( DECREF(p->stype), p->dimoff, p->sizoff ) / SZCHAR;		count = size/2;		while( count-- ) {			printf( "	mov	(r0)+,(r1)+/n" );			}		printf( "	mov	$L%d,r0/n", stlab );		printf( "	.bss/nL%d:	.=.+%d./n	.text/n", stlab, size );		/* turn off strftn flag, so return sequence will be generated */		strftn = 0;		}	branch( retlab );	p2bend();	}

/* * Fixup struct/unions depending on attributes. */voidgcc_tcattrfix(NODE *p){    struct symtab *sp;    struct attr *ap;    int sz, coff, csz, al;    if ((ap = attr_find(p->n_ap, GCC_ATYP_PACKED)) == NULL)        return; /* nothing to fix */    al = ap->iarg(0);    /* Must repack struct */    coff = csz = 0;    for (sp = strmemb(ap); sp; sp = sp->snext) {        if (sp->sclass & FIELD)            sz = sp->sclass&FLDSIZ;        else            sz = (int)tsize(sp->stype, sp->sdf, sp->sap);        SETOFF(sz, al);        sp->soffset = coff;        coff += sz;        if (coff > csz)            csz = coff;        if (p->n_type == UNIONTY)            coff = 0;    }    SETOFF(csz, al); /* Roundup to whatever */    ap = attr_find(p->n_ap, ATTR_BASETYP);    ap->atypsz = csz;    ap->aalign = al;}

/* called by moveargs() */static NODE *pusharg(NODE *p, int *regp){	NODE *q;	int sz;	/* convert to register size, if smaller */	sz = tsize(p->n_type, p->n_df, p->n_ap);	if (sz < SZINT)		p = block(SCONV, p, NIL, INT, 0, 0);	q = block(REG, NIL, NIL, INT, 0, 0);	regno(q) = SP;	if (szty(p->n_type) == 1) {		++(*regp);		q = block(MINUSEQ, q, bcon(4), INT, 0, 0);	} else {		(*regp) += 2;		q = block(MINUSEQ, q, bcon(8), INT, 0, 0);	}	q = block(UMUL, q, NIL, p->n_type, p->n_df, p->n_ap);	return buildtree(ASSIGN, q, p);}

static NODE *builtin_stdarg_start(const struct bitable *bt, NODE *a){    NODE *p, *q;    int sz;    /* must first deal with argument size; use int size */    p = a->n_right;    if (p->n_type < INT) {        sz = (int)(SZINT/tsize(p->n_type, p->n_df, p->n_ap));    } else        sz = 1;    /* do the real job */    p = buildtree(ADDROF, p, NIL); /* address of last arg */#ifdef BACKAUTO    p = optim(buildtree(PLUS, p, bcon(sz))); /* add one to it (next arg) */#else    p = optim(buildtree(MINUS, p, bcon(sz))); /* add one to it (next arg) */#endif    q = block(NAME, NIL, NIL, PTR+VOID, 0, 0); /* create cast node */    q = buildtree(CAST, q, p); /* cast to void * (for assignment) */    p = q->n_right;    nfree(q->n_left);    nfree(q);    p = buildtree(ASSIGN, a->n_left, p); /* assign to ap */    nfree(a);    return p;}

/* * AMD64 parameter classification. */static intargtyp(TWORD t, union dimfun *df, struct attr *ap){	int cl = 0;	if (t <= ULONG || ISPTR(t) || t == BOOL) {		cl = ngpr < 6 ? INTEGER : INTMEM;	} else if (t == FLOAT || t == DOUBLE || t == FIMAG || t == IMAG) {		cl = nsse < 8 ? SSE : SSEMEM;	} else if (t == LDOUBLE || t == LIMAG) {		cl = X87; /* XXX */	} else if (t == STRTY || t == UNIONTY) {		int sz = tsize(t, df, ap);		if (sz <= 2*SZLONG && attr_find(ap, ATTR_COMPLEX) != NULL) {			cl = nsse < 7 ? STRCPX : STRMEM;		} else if (sz > 2*SZLONG || ((sz+SZLONG)/SZLONG)+ngpr > 6 ||		    attr_find(ap, GCC_ATYP_PACKED) != NULL)			cl = STRMEM;		else			cl = STRREG;	} else		cerror("FIXME: classify");	return cl;}

static NODE *builtin_va_arg(const struct bitable *bt, NODE *a){    NODE *p, *q, *r, *rv;    int sz, nodnum;    /* create a copy to a temp node of current ap */    p = ccopy(a->n_left);    q = tempnode(0, p->n_type, p->n_df, p->n_ap);    nodnum = regno(q);    rv = buildtree(ASSIGN, q, p);    r = a->n_right;    sz = (int)tsize(r->n_type, r->n_df, r->n_ap)/SZCHAR;    /* add one to ap */#ifdef BACKAUTO    rv = buildtree(COMOP, rv , buildtree(PLUSEQ, a->n_left, bcon(sz)));#else#error fix wrong eval order in builtin_va_arg    ecomp(buildtree(MINUSEQ, a->n_left, bcon(sz)));#endif    nfree(a->n_right);    nfree(a);    r = tempnode(nodnum, INCREF(r->n_type), r->n_df, r->n_ap);    return buildtree(COMOP, rv, buildtree(UMUL, r, NIL));}

/* * va_start(ap, last) implementation. * * f is the NAME node for this builtin function. * a is the argument list containing: *	   CM *	ap   last * * It turns out that this is easy on MIPS.  Just write the * argument registers to the stack in va_arg_start() and * use the traditional method of walking the stackframe. */NODE *mips_builtin_stdarg_start(NODE *f, NODE *a, TWORD t){	NODE *p, *q;	int sz = 1;	/* check num args and type */	if (a == NULL || a->n_op != CM || a->n_left->n_op == CM ||	    !ISPTR(a->n_left->n_type))		goto bad;	/* must first deal with argument size; use int size */	p = a->n_right;	if (p->n_type < INT) {		/* round up to word */		sz = SZINT / tsize(p->n_type, p->n_df, p->n_ap);	}	p = buildtree(ADDROF, p, NIL);	/* address of last arg */	p = optim(buildtree(PLUS, p, bcon(sz)));	q = block(NAME, NIL, NIL, PTR+VOID, 0, 0);	q = buildtree(CAST, q, p);	p = q->n_right;	nfree(q->n_left);	nfree(q);	p = buildtree(ASSIGN, a->n_left, p);	tfree(f);	nfree(a);	return p;bad:	uerror("bad argument to __builtin_stdarg_start");	return bcon(0);}

/* * code for the end of a function * deals with struct return here */voidefcode(void){	NODE *p, *q;	int sz;	if (cftnsp->stype != STRTY+FTN && cftnsp->stype != UNIONTY+FTN)		return;	/* address of return struct is in %ret0 */	/* create a call to memcpy() */	/* will get the result in %ret0 */	p = block(REG, NIL, NIL, CHAR+PTR, 0, 0);	p->n_rval = RET0;	q = block(OREG, NIL, NIL, CHAR+PTR, 0, 0);	q->n_rval = FP;	q->n_lval = 8; /* return buffer offset */	p = block(CM, q, p, INT, 0, 0);	sz = (tsize(STRTY, cftnsp->sdf, cftnsp->ssue)+SZCHAR-1)/SZCHAR;	p = block(CM, p, bcon(sz), INT, 0, 0);	p->n_right->n_name = "";	p = block(CALL, bcon(0), p, CHAR+PTR, 0, 0);	p->n_left->n_name = "memcpy";	p = clocal(p);	send_passt(IP_NODE, p);}

voidmyp2tree(NODE *p){	struct symtab *sp;	if (p->n_op != FCON) 		return;	/* Write float constants to memory */ 	sp = IALLOC(sizeof(struct symtab));	sp->sclass = STATIC;	sp->sap = 0;	sp->slevel = 1; /* fake numeric label */	sp->soffset = getlab();	sp->sflags = 0;	sp->stype = p->n_type;	sp->squal = (CON >> TSHIFT);	defloc(sp);	ninval(0, tsize(sp->stype, sp->sdf, sp->sap), p);	p->n_op = NAME;	p->n_lval = 0;	p->n_sp = sp;}

wxSize wxChoice::DoGetSizeFromTextSize(int xlen, int ylen) const{    int cHeight = GetCharHeight();    // We are interested in the difference of sizes between the whole control    // and its child part. I.e. arrow, separators, etc.    wxSize tsize(xlen, 0);    // FIXME-VC6: Only VC6 needs this guard, see WINVER definition in    //            include/wx/msw/wrapwin.h#if defined(WINVER) && WINVER >= 0x0500    WinStruct<COMBOBOXINFO> info;    if ( MSWGetComboBoxInfo(&info) )    {        tsize.x += info.rcItem.left + info.rcButton.right - info.rcItem.right                    + info.rcItem.left + 3; // right and extra margins    }    else // Just use some rough approximation.#endif // WINVER >= 0x0500    {        tsize.x += 4*cHeight;    }    // set height on our own    if( HasFlag( wxCB_SIMPLE ) )        tsize.y = SetHeightSimpleComboBox(GetCount());    else        tsize.y = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cHeight);    // Perhaps the user wants something different from CharHeight    if ( ylen > 0 )        tsize.IncBy(0, ylen - cHeight);    return tsize;}

/* setup struct parameter * push the registers out to memory * used by bfcode() */static voidparam_struct(struct symtab *sym, int *argofsp){	int argofs = *argofsp;	NODE *p, *q;	int navail;	int sz;	int off;	int num;	int i;	navail = NARGREGS - argofs;	sz = tsize(sym->stype, sym->sdf, sym->sap) / SZINT;	off = ARGINIT/SZINT + argofs;	num = sz > navail ? navail : sz;	for (i = 0; i < num; i++) {		q = block(REG, NIL, NIL, INT, 0, 0);		regno(q) = R0 + argofs++;		p = block(REG, NIL, NIL, INT, 0, 0);		regno(p) = SP;		p = block(PLUS, p, bcon(4*off++), INT, 0, 0);		p = block(UMUL, p, NIL, INT, 0, 0);		p = buildtree(ASSIGN, p, q);		ecomp(p);	}	*argofsp = argofs;}

wxSize wxChoice::DoGetSizeFromTextSize(int xlen, int ylen) const{    wxASSERT_MSG( m_widget, wxS("GetSizeFromTextSize called before creation") );    // a GtkEntry for wxComboBox and a GtkCellView for wxChoice    GtkWidget* childPart = gtk_bin_get_child(GTK_BIN(m_widget));    // Set a as small as possible size for the control, so preferred sizes    // return "natural" sizes, not taking into account the previous ones (which    // seems to be GTK+3 behaviour)    gtk_widget_set_size_request(m_widget, 0, 0);    // We are interested in the difference of sizes between the whole contol    // and its child part. I.e. arrow, separators, etc.    GtkRequisition req;    gtk_widget_get_preferred_size(childPart, NULL, &req);    wxSize totalS = GTKGetPreferredSize(m_widget);    wxSize tsize(xlen + totalS.x - req.width, totalS.y);    // For a wxChoice, not for wxComboBox, add some margins    if ( !GTK_IS_ENTRY(childPart) )        tsize.IncBy(5, 0);    // Perhaps the user wants something different from CharHeight    if ( ylen > 0 )        tsize.IncBy(0, ylen - GetCharHeight());    return tsize;}

wxSize wxSpinCtrlGTKBase::DoGetSizeFromTextSize(int xlen, int ylen) const{    wxASSERT_MSG( m_widget, wxS("GetSizeFromTextSize called before creation") );    // Set an as small as possible size for the control, so preferred sizes    // return "natural" sizes, not taking into account the previous ones (which    // seems to be GTK+3 behaviour)    gtk_widget_set_size_request(m_widget, 0, 0);    // Both Gtk+2 and Gtk+3 use current value/range to measure control's width.    // So, we can't ask Gtk+ for its width. Instead, we used hardcoded values.    // Returned height is OK    wxSize totalS = GTKGetPreferredSize(m_widget);#if GTK_CHECK_VERSION(3,4,0)    // two buttons in horizontal    totalS.x = 46 + 15; // margins included#else    // two small buttons in vertical    totalS.x = GetFont().GetPixelSize().y + 13; // margins included#endif    wxSize tsize(xlen + totalS.x, totalS.y);    // Check if the user requested a non-standard height.    if ( ylen > 0 )        tsize.IncBy(0, ylen - GetCharHeight());    return tsize;}

voidsetintegral(void) {	const char *f;	yyval.token = oalloc();	f = "//(is";#ifndef NEQN	printf(".ds %d //s%s//v'.1m'//s+4%s//s-4//v'-.1m'//s%s/n", 		yyval.token, tsize(ps), f, tsize(ps));	eht[yyval.token] = VERT(EM(1.15, ps+4));	ebase[yyval.token] = VERT(EM(0.3, ps));#else /* NEQN */	printf(".ds %d %s/n", yyval.token, f);	eht[yyval.token] = VERT(2);	ebase[yyval.token] = 0;#endif /* NEQN */	lfont[yyval.token] = rfont[yyval.token] = ROM;}

/* make a common declaration for id, if reasonable */voidcommdec(struct symtab *q){	int off;	off = tsize(q->stype, q->sdf, q->ssue);	off = (off+(SZCHAR-1))/SZCHAR;	printf("	.comm %s,0%o/n", exname(q->soname), off);}

/* * code for the end of a function * deals with struct return here * The return value is in (or pointed to by) RETREG. */voidefcode(void){	struct symtab *sp;	extern int gotnr;	TWORD t;	NODE *p, *r, *l;	int typ, ssz, rno;	gotnr = 0;	/* new number for next fun */	sp = cftnsp;	t = DECREF(sp->stype);	if (t != STRTY && t != UNIONTY)		return;	/* XXX should have one routine for this */	ngpr = nsse = 0;	if ((typ = argtyp(t, sp->sdf, sp->sap)) == STRREG || typ == STRCPX) {		/* Cast to long pointer and move to the registers */		/* XXX can overrun struct size */		/* XXX check carefully for SSE members */		if ((ssz = tsize(t, sp->sdf, sp->sap)) > SZLONG*2)			cerror("efcode1");		if (typ == STRCPX) {			t = DOUBLE;			rno = XMM0;		} else {			t = LONG;			rno = RAX;		}		if (ssz > SZLONG) {			p = block(REG, NIL, NIL, INCREF(t), 0, 0);			regno(p) = RAX;			p = buildtree(UMUL, buildtree(PLUS, p, bcon(1)), NIL);			ecomp(movtoreg(p, rno+1));		}		p = block(REG, NIL, NIL, INCREF(t), 0, 0);		regno(p) = RAX;		p = buildtree(UMUL, p, NIL);		ecomp(movtoreg(p, rno));	} else if (typ == STRMEM) {		r = block(REG, NIL, NIL, INCREF(t), sp->sdf, sp->sap);		regno(r) = RAX;		r = buildtree(UMUL, r, NIL);		l = tempnode(stroffset, INCREF(t), sp->sdf, sp->sap);		l = buildtree(UMUL, l, NIL);		ecomp(buildtree(ASSIGN, l, r));		l = block(REG, NIL, NIL, LONG, 0, 0);		regno(l) = RAX;		r = tempnode(stroffset, LONG, 0, 0);		ecomp(buildtree(ASSIGN, l, r));	} else		cerror("efcode");}

NODE *mips_builtin_va_arg(NODE *f, NODE *a, TWORD t){	NODE *p, *q, *r;	int sz, tmpnr;	/* check num args and type */	if (a == NULL || a->n_op != CM || a->n_left->n_op == CM ||	    !ISPTR(a->n_left->n_type) || a->n_right->n_op != TYPE)		goto bad;	r = a->n_right;	/* get type size */	sz = tsize(r->n_type, r->n_df, r->n_ap) / SZCHAR;	if (sz < SZINT/SZCHAR) {		werror("%s%s promoted to int when passed through ...",			r->n_type & 1 ? "unsigned " : "",			DEUNSIGN(r->n_type) == SHORT ? "short" : "char");		sz = SZINT/SZCHAR;	}	/* alignment */	p = tcopy(a->n_left);	if (sz > SZINT/SZCHAR && r->n_type != UNIONTY && r->n_type != STRTY) {		p = buildtree(PLUS, p, bcon(7));		p = block(AND, p, bcon(-8), p->n_type, p->n_df, p->n_ap);	}	/* create a copy to a temp node */	q = tempnode(0, p->n_type, p->n_df, p->n_ap);	tmpnr = regno(q);	p = buildtree(ASSIGN, q, p);	q = tempnode(tmpnr, p->n_type, p->n_df,p->n_ap);	q = buildtree(PLUS, q, bcon(sz));	q = buildtree(ASSIGN, a->n_left, q);	q = buildtree(COMOP, p, q);	nfree(a->n_right);	nfree(a);	nfree(f); 	p = tempnode(tmpnr, INCREF(r->n_type), r->n_df, r->n_ap);	p = buildtree(UMUL, p, NIL);	p = buildtree(COMOP, q, p);	return p;bad:	uerror("bad argument to __builtin_va_arg");	return bcon(0);}

/* * Called with a function call with arguments as argument. * This is done early in buildtree() and only done once. * Returns p. */NODE *funcode(NODE *p){	NODE *l, *r;	TWORD t;	int i;	nsse = ngpr = nrsp = 0;	/* Check if hidden arg needed */	/* If so, add it in pass2 */	if ((l = p->n_left)->n_type == INCREF(FTN)+STRTY ||	    l->n_type == INCREF(FTN)+UNIONTY) {		int ssz = tsize(BTYPE(l->n_type), l->n_df, l->n_ap);		if (ssz > 2*SZLONG)			ngpr++;	}	/* Convert just regs to assign insn's */	p->n_right = argput(p->n_right);	/* Must sort arglist so that STASG ends up first */	/* This avoids registers being clobbered */	while (argsort(p->n_right))		;	/* Check if there are varargs */	if (nsse || l->n_df == NULL || l->n_df->dfun == NULL) {		; /* Need RAX */	} else {		union arglist *al = l->n_df->dfun;		for (; al->type != TELLIPSIS; al++) {			if ((t = al->type) == TNULL)				return p; /* No need */			if (ISSOU(BTYPE(t)))				al++;			for (i = 0; t > BTMASK; t = DECREF(t))				if (ISARY(t) || ISFTN(t))					i++;			if (i)				al++;		}	}	/* Always emit number of SSE regs used */	l = movtoreg(bcon(nsse), RAX);	if (p->n_right->n_op != CM) {		p->n_right = block(CM, l, p->n_right, INT, 0, 0);	} else {		for (r = p->n_right; r->n_left->n_op == CM; r = r->n_left)			;		r->n_left = block(CM, l, r->n_left, INT, 0, 0);	}	return p;}

  void ColorFading::setSize(const geo::IntSize &size)  {    IntSize tsize(size);    if(size.getWidth() < 0)      tsize.setWidth(gfx::getScreenSize().getWidth());    if(size.getHeight() < 0)      tsize.setHeight(gfx::getScreenSize().getHeight());    image.setSize(tsize);    image.fill(color);  }

/* make a local common declaration for id, if reasonable */voidlcommdec(struct symtab *q){	int off;	off = tsize(q->stype, q->sdf, q->ssue);	off = (off+(SZCHAR-1))/SZCHAR;	if (q->slevel == 0)		printf("	.lcomm %s,0%o/n", exname(q->soname), off);	else		printf("	.lcomm " LABFMT ",0%o/n", q->soffset, off);}

voidboverb(int p1, int p2) {	int treg;#ifndef	NEQN	float h, b, d;#else	/* NEQN */	int h, b, d;#endif	/* NEQN */	treg = oalloc();	yyval.token = p1;#ifndef NEQN	d = VERT(EM(0.3, ps));	h = eht[p1] + eht[p2] + d;#else /* NEQN */	d = VERT(1);	h = eht[p1] + eht[p2];#endif /* NEQN */	b = eht[p2] - d;#ifndef	NEQN	if(dbg)printf("./tb:bob: S%d <- S%d over S%d; b=%g, h=%g/n", 		yyval.token, p1, p2, b, h);#else	/* NEQN */	if(dbg)printf("./tb:bob: S%d <- S%d over S%d; b=%d, h=%d/n", 		yyval.token, p1, p2, b, h);#endif	/* NEQN */	nrwid(p1, ps, p1);	nrwid(p2, ps, p2);	printf(".nr %d //n(%d/n", treg, p1);	printf(".if //n(%d>//n(%d .nr %d //n(%d/n", p2, treg, treg, p2);#ifndef NEQN	printf(".nr %d //n(%d+//s%s.5m//s0/n", treg, treg, tsize(EFFPS(ps)));	printf(".ds %d //v'%gp'//h'//n(%du-//n(%du/2u'//*(%d///n", 		yyval.token, eht[p2]-ebase[p2]-d, treg, p2, p2);	printf("//h'-//n(%du-//n(%du/2u'//v'%gp'//*(%d///n", 		p2, p1, -(eht[p2]-ebase[p2]+d+ebase[p1]), p1);	printf("//h'-//n(%du-//n(%du/2u+.1m'//v'%gp'//l'//n(%du-.2m'//h'.1m'//v'%gp'/n", 		 treg, p1, ebase[p1]+d, treg, d);#else /* NEQN */	printf(".ds %d //v'%du'//h'//n(%du-//n(%du/2u'//*(%d///n", 		yyval.token, eht[p2]-ebase[p2]-d, treg, p2, p2);	printf("//h'-//n(%du-//n(%du/2u'//v'%du'//*(%d///n", 		p2, p1, -eht[p2]+ebase[p2]-ebase[p1], p1);	printf("//h'-//n(%du-//n(%du-2u/2u'//v'%du'//l'//n(%du'//v'%du'/n", 		 treg, p1, ebase[p1], treg, d);#endif /* NEQN */	ebase[yyval.token] = b;	eht[yyval.token] = h;	lfont[yyval.token] = rfont[yyval.token] = 0;	ofree(p2);	ofree(treg);}

/* make a common declaration for id, if reasonable */voiddefzero(struct symtab *sp){	int off;	off = tsize(sp->stype, sp->sdf, sp->sap);	off = (off+(SZCHAR-1))/SZCHAR;	printf("	.%scomm ", sp->sclass == STATIC ? "l" : "");	if (sp->slevel == 0)		printf("%s,0%o/n", sp->soname ? sp->soname : exname(sp->sname), off);	else		printf(LABFMT ",0%o/n", sp->soffset, off);}

/* * return a node, for structure references, which is suitable for * being added to a pointer of type t, in order to be off bits offset * into a structure * t, d, and s are the type, dimension offset, and sizeoffset * For nova, return the type-specific index number which calculation * is based on its size. For example, char a[3] would return 3. * Be careful about only handling first-level pointers, the following * indirections must be fullword. */NODE *offcon(OFFSZ off, TWORD t, union dimfun *d, struct attr *ap){	register NODE *p;	if (xdebug)		printf("offcon: OFFSZ %ld type %x dim %p siz %ld/n",		    off, t, d, tsize(t, d, ap));	p = bcon(off/SZINT);	if (t == INCREF(CHAR) || t == INCREF(UCHAR) || t == INCREF(VOID))		p->n_lval = off/SZCHAR; /* pointer to char */	return(p);}

voidputout(int p1) {#ifndef	NEQN	float before, after;	if(dbg)printf("./tanswer <- S%d, h=%g,b=%g/n",p1, eht[p1], ebase[p1]);#else	/* NEQN */	int before, after;	if(dbg)printf("./tanswer <- S%d, h=%d,b=%d/n",p1, eht[p1], ebase[p1]);#endif	/* NEQN */	eqnht = eht[p1];	printf(".ds %d ", p1);	/* suppposed to leave room for a subscript or superscript */#ifndef NEQN	before = eht[p1] - ebase[p1] - VERT(EM(1.2, ps));#else /* NEQN */	before = eht[p1] - ebase[p1] - VERT(3);	/* 3 = 1.5 lines */#endif /* NEQN */	if (spaceval != NULL)		printf("//x'0-%s'", spaceval);	else if (before > 0)#ifndef	NEQN		printf("//x'0-%gp'", before);#else	/* NEQN */		printf("//x'0-%du'", before);#endif	/* NEQN */	printf("//f%c//s%s//*(%d%s/n",		gfont, tsize(gsize), p1, ital(rfont[p1]) ? "//|" : "");	printf(".ie //n(.X=0 .as %d //s//n(99/n", p1);	printf(".el .as %d //s[//n(99]/n", p1);	printf(".as %d //f//n(98", p1);#ifndef NEQN	after = ebase[p1] - VERT(EM(0.2, ps));#else /* NEQN */	after = ebase[p1] - VERT(1);#endif /* NEQN */	if (spaceval == NULL && after > 0)#ifndef	NEQN		printf("//x'%gp'", after);#else	/* NEQN */		printf("//x'%du'", after);#endif	/* NEQN */	putchar('/n');	eqnreg = p1;	if (spaceval != NULL) {		free(spaceval);		spaceval = NULL;	}}

wxSize wxComboBox::DoGetSizeFromTextSize(int xlen, int ylen) const{    wxSize tsize( wxChoice::DoGetSizeFromTextSize(xlen, ylen) );    if ( !HasFlag(wxCB_READONLY) )    {        // Add the margins we have previously set        wxPoint marg( GetMargins() );        marg.x = wxMax(0, marg.x);        marg.y = wxMax(0, marg.y);        tsize.IncBy( marg );    }    return tsize;}