NODE *
rstruct( idn, soru ){ /* reference to a structure or union, with no definition */
register struct symtab *p;
register NODE *q;
p = &stab[idn];
switch( p->stype ){
case UNDEF:
def:
q = block( FREE, NIL, NIL, 0, 0, 0 );
q->rval = idn;
q->type = (soru&INSTRUCT) ? STRTY : ( (soru&INUNION) ? UNIONTY : ENUMTY );
defid( q, (soru&INSTRUCT) ? STNAME : ( (soru&INUNION) ? UNAME : ENAME ) );
break;
case STRTY:
if( soru & INSTRUCT ) break;
goto def;
case UNIONTY:
if( soru & INUNION ) break;
goto def;
case ENUMTY:
if( !(soru&(INUNION|INSTRUCT)) ) break;
goto def;
}
stwart = instruct;
return( mkty( p->stype, 0, p->sizoff ) );
}
/*
* Reference to a struct as a :: name.
*/
NODE *
cxxrstruct(int soru, NODE *attr, NODE *t, char *n)
{
struct symtab *ns, *sp;
ns = pfind(t, spole->sup);
if (ns == NULL)
goto undecl;
tfree(t);
sp = sfind(n, ns);
while (sp != NULL) {
if (sp->sclass == soru)
return mkty(sp->stype, 0, sp->sap);
sp = sfind(n, sp->snext);
}
undecl:
uerror("%s undeclared", n);
return mkty(INT, 0, 0);
}
/*
* See if a string matches a gcc keyword.
*/
int
gcc_keyword(char *str, NODE **n)
{
extern int inattr, parlvl, parbal;
YYSTYPE *yyl = (YYSTYPE *)n; /* XXX should pass yylval */
char tlbuf[TLLEN], *tw;
struct kw *kwp;
int i;
/* XXX hack, should pass everything in expressions */
if (str == kw[21].ptr)
return kw[21].rv;
if (inattr)
return 0;
for (i = 0, kwp = kw; kwp->name; kwp++, i++)
if (str == kwp->ptr)
break;
if (kwp->name == NULL)
return 0;
if (kwp->rv)
return kwp->rv;
switch (i) {
case 1: /* __signed */
case 14: /* __signed__ */
*n = mkty((TWORD)SIGNED, 0, 0);
return C_TYPE;
case 3: /* __const */
*n = block(QUALIFIER, NIL, NIL, CON, 0, 0);
(*n)->n_qual = CON;
return C_QUALIFIER;
case 6: /* __thread */
snprintf(tlbuf, TLLEN, TS, lineno);
tw = &tlbuf[strlen(tlbuf)];
while (tw > tlbuf)
cunput(*--tw);
return -1;
case 7: /* __FUNCTION__ */
case 20: /* __PRETTY_FUNCTION__ */
if (cftnsp == NULL) {
uerror("%s outside function", kwp->name);
yylval.strp = "";
} else
yylval.strp = cftnsp->sname; /* XXX - not C99 */
return C_STRING;
case 8: /* __volatile */
case 9: /* __volatile__ */
*n = block(QUALIFIER, NIL, NIL, VOL, 0, 0);
(*n)->n_qual = VOL;
return C_QUALIFIER;
case 15: /* __attribute__ */
case 16: /* __attribute */
inattr = 1;
parlvl = parbal;
return C_ATTRIBUTE;
case 17: /* __real__ */
yyl->intval = XREAL;
return C_UNOP;
case 18: /* __imag__ */
yyl->intval = XIMAG;
return C_UNOP;
}
cerror("gcc_keyword");
return 0;
}
NODE *
dclstruct( oparam ){
register struct symtab *p;
register i, al, sa, j, sz, szindex;
register TWORD temp;
register high, low;
/* paramstack contains:
paramstack[ oparam ] = previous instruct
paramstack[ oparam+1 ] = previous class
paramstk[ oparam+2 ] = previous strucoff
paramstk[ oparam+3 ] = structure name
paramstk[ oparam+4, ... ] = member stab indices
*/
if( (i=paramstk[oparam+3]) < 0 ){
szindex = curdim;
dstash( 0 ); /* size */
dstash( -1 ); /* index to member names */
dstash( ALSTRUCT ); /* alignment */
}
else {
szindex = stab[i].sizoff;
}
if( ddebug ){
printf( "dclstruct( %.8s ), szindex = %d\n", (i>=0)? stab[i].sname : "??", szindex );
}
temp = (instruct&INSTRUCT)?STRTY:((instruct&INUNION)?UNIONTY:ENUMTY);
stwart = instruct = paramstk[ oparam ];
curclass = paramstk[ oparam+1 ];
dimtab[ szindex+1 ] = curdim;
al = ALSTRUCT;
high = low = 0;
for( i = oparam+4; i< paramno; ++i ){
dstash( j=paramstk[i] );
if( j<0 || j>= SYMTSZ ) cerror( "gummy structure member" );
p = &stab[j];
if( temp == ENUMTY ){
if( p->offset < low ) low = p->offset;
if( p->offset > high ) high = p->offset;
p->sizoff = szindex;
continue;
}
sa = talign( p->stype, p->sizoff );
if( p->sclass & FIELD ){
sz = p->sclass&FLDSIZ;
}
else {
sz = tsize( p->stype, p->dimoff, p->sizoff );
}
if( sz == 0 ){
uerror( "illegal zero sized structure member: %.8s", p->sname );
}
if( sz > strucoff ) strucoff = sz; /* for use with unions */
SETOFF( al, sa );
/* set al, the alignment, to the lcm of the alignments of the members */
}
dstash( -1 ); /* endmarker */
SETOFF( strucoff, al );
if( temp == ENUMTY ){
register TWORD ty;
# ifdef ENUMSIZE
ty = ENUMSIZE(high,low);
# else
if( (char)high == high && (char)low == low ) ty = ctype( CHAR );
else if( (short)high == high && (short)low == low ) ty = ctype( SHORT );
else ty = ctype(INT);
#endif
strucoff = tsize( ty, 0, (int)ty );
dimtab[ szindex+2 ] = al = talign( ty, (int)ty );
}
if( strucoff == 0 ) uerror( "zero sized structure" );
dimtab[ szindex ] = strucoff;
dimtab[ szindex+2 ] = al;
if( ddebug>1 ){
printf( "\tdimtab[%d,%d,%d] = %d,%d,%d\n", szindex,szindex+1,szindex+2,
dimtab[szindex],dimtab[szindex+1],dimtab[szindex+2] );
for( i = dimtab[szindex+1]; dimtab[i] >= 0; ++i ){
printf( "\tmember %.8s(%d)\n", stab[dimtab[i]].sname, dimtab[i] );
}
}
strucoff = paramstk[ oparam+2 ];
paramno = oparam;
return( mkty( temp, 0, szindex ) );
}