decl.c File Reference

#include "c.h"

Include dependency graph for decl.c:

Go to the source code of this file.

Defines
#define	add(x, n)   (x > inttype->u.sym->u.limits.max.i-(n) ? (overflow=1,x) : x+(n))
#define	bits2bytes(n)   (((n) + 7)/8)
#define	chkoverflow(x, n)   ((void)add(x,n))
Functions
void	checklab (Symbol p, void *cl)
void	checkref (Symbol, void *)
void	compound (int loop, struct swtch *swp, int lev)
Symbol	dclglobal (int, char *, Type, Coordinate *)
Symbol	dcllocal (int, char *, Type, Coordinate *)
Symbol	dclparam (int, char *, Type, Coordinate *)
Type	dclr (Type, char **, Symbol **, int)
Type	dclr1 (char **, Symbol **, int)
void	decl (Symbol(*)(int, char *, Type, Coordinate *))
void	defglobal (Symbol p, int seg)
void	doconst (Symbol, void *)
void	doextern (Symbol, void *)
void	doglobal (Symbol, void *)
Type	enumdcl (void)
void	exitparams (Symbol[])
void	fields (Type)
void	finalize (void)
void	funcdefn (int, char *, Type, Symbol[], Coordinate)
void	initglobal (Symbol, int)
void	oldparam (Symbol, void *)
Symbol *	parameters (Type)
void	program (void)
Type	specifier (int *)
Type	structdcl (int)
Type	tnode (int, Type)
Type	typename (void)
Variables
List	autos
Symbol	cfunc
int	regcount
List	registers
Symbol	retv

---

Define Documentation

#define add (  x, n   )     (x > inttype->u.sym->u.limits.max.i-(n) ? (overflow=1,x) : x+(n))

Definition at line 4 of file decl.c. Referenced by AsmCall(), LightContributionToPoint(), LightingAtSample(), TraceGrid(), VL_LightSurfaceWithVolume(), and VS_LightSurfaceWithVolume().

#define bits2bytes (  n   )     (((n) + 7)/8)

Definition at line 6 of file decl.c.

#define chkoverflow (  x, n   )     ((void)add(x,n))

Definition at line 5 of file decl.c.

---

Function Documentation

void checklab (  Symbol  p, void *  cl )

Definition at line 1071 of file decl.c. References symbol::defined, error(), symbol::name, p, and Symbol. Referenced by funcdefn(). { if (!p->defined) error("undefined label `%s'\n", p->name); p->defined = 1; }

Here is the call graph for this function:

void checkref (  Symbol  , void *  )  [static]

Definition at line 895 of file decl.c. References symbol::addressed, Aflag, assert, symbol::defined, error(), GLOBAL, isfunc, isscalar, isvolatile, level, LOCAL, symbol::name, p, PARAM, symbol::ref, regcount, symbol::sclass, symbol::scope, Symbol, symbol::type, and warning(). Referenced by compound(), finalize(), and funcdefn(). { if (p->scope >= PARAM && (isvolatile(p->type) || isfunc(p->type))) p->addressed = 1; if (Aflag >= 2 && p->defined && p->ref == 0) { if (p->sclass == STATIC) warning("static `%t %s' is not referenced\n", p->type, p->name); else if (p->scope == PARAM) warning("parameter `%t %s' is not referenced\n", p->type, p->name); else if (p->scope >= LOCAL && p->sclass != EXTERN) warning("local `%t %s' is not referenced\n", p->type, p->name); } if (p->sclass == AUTO && (p->scope == PARAM && regcount == 0 || p->scope >= LOCAL) && !p->addressed && isscalar(p->type) && p->ref >= 3.0) p->sclass = REGISTER; if (level == GLOBAL && p->sclass == STATIC && !p->defined && isfunc(p->type) && p->ref) error("undefined static `%t %s'\n", p->type, p->name); assert(!(level == GLOBAL && p->sclass == STATIC && !p->defined && !isfunc(p->type))); }

Here is the call graph for this function:

void compound (  int  loop, struct swtch *  swp, int  lev )

Definition at line 835 of file decl.c. References a, append(), apply(), assert, autos, code::begin, code::block, Events::blockentry, Events::blockexit, cfunc, CHAR, checkref(), code(), Code, cp, dcllocal(), decl(), symbol::defined, definept(), enterscope(), Events::entry, events, exitscope(), expect(), foreach(), freturn(), FUNC, genident(), getchr(), i, code::identifiers, identifiers, IR, isstruct, istypename, j, kind, length(), code::level, level, LOCAL, code::locals, ltov(), NULL, p, ptr(), reachable(), symbol::ref, registers, retv, statement(), STMT, Symbol, t, tsym, symbol::type, code::types, code::u, walk(), and interface::wants_callb. Referenced by funcdefn(), and statement(). { Code cp; int nregs; walk(NULL, 0, 0); cp = code(Blockbeg); enterscope(); assert(level >= LOCAL); if (level == LOCAL && events.entry) apply(events.entry, cfunc, NULL); definept(NULL); expect('{'); autos = registers = NULL; if (level == LOCAL && IR->wants_callb && isstruct(freturn(cfunc->type))) { retv = genident(AUTO, ptr(freturn(cfunc->type)), level); retv->defined = 1; retv->ref = 1; registers = append(retv, registers); } while (kind[t] == CHAR || kind[t] == STATIC || istypename(t, tsym) && getchr() != ':') decl(dcllocal); { int i; Symbol *a = ltov(&autos, STMT); nregs = length(registers); for (i = 0; a[i]; i++) registers = append(a[i], registers); cp->u.block.locals = ltov(&registers, FUNC); } if (events.blockentry) apply(events.blockentry, cp->u.block.locals, NULL); while (kind[t] == IF || kind[t] == ID) statement(loop, swp, lev); walk(NULL, 0, 0); foreach(identifiers, level, checkref, NULL); { int i = nregs, j; Symbol p; for ( ; (p = cp->u.block.locals[i]) != NULL; i++) { for (j = i; j > nregs && cp->u.block.locals[j-1]->ref < p->ref; j--) cp->u.block.locals[j] = cp->u.block.locals[j-1]; cp->u.block.locals[j] = p; } } if (events.blockexit) apply(events.blockexit, cp->u.block.locals, NULL); cp->u.block.level = level; cp->u.block.identifiers = identifiers; cp->u.block.types = types; code(Blockend)->u.begin = cp; if (reachable(Gen)) definept(NULL); if (level > LOCAL) { exitscope(); expect('}'); } }

Here is the call graph for this function:

Symbol dclglobal (  int  , char *  , Type  , Coordinate *  )  [static]

Definition at line 203 of file decl.c. References Aflag, compose(), Coordinate, symbol::defined, interface::defsymbol, eqtype(), error(), EXTERN, externals, gettok(), glevel, GLOBAL, globals, identifiers, initglobal(), initializer(), install(), IR, isfunc, lookup(), symbol::name, NULL, p, PERM, q, relocate(), symbol::sclass, symbol::scope, symbol::seg, type::size, symbol::src, interface::stabsym, swtoseg(), Symbol, t, symbol::type, Type, symbol::u, and warning(). Referenced by funcdefn(), and program(). { Symbol p; if (sclass == 0) sclass = AUTO; else if (sclass != EXTERN && sclass != STATIC) { error("invalid storage class `%k' for `%t %s'\n", sclass, ty, id); sclass = AUTO; } p = lookup(id, identifiers); if (p && p->scope == GLOBAL) { if (p->sclass != TYPEDEF && eqtype(ty, p->type, 1)) ty = compose(ty, p->type); else error("redeclaration of `%s' previously declared at %w\n", p->name, &p->src); if (!isfunc(ty) && p->defined && t == '=') error("redefinition of `%s' previously defined at %w\n", p->name, &p->src); if (p->sclass == EXTERN && sclass == STATIC || p->sclass == STATIC && sclass == AUTO || p->sclass == AUTO && sclass == STATIC) warning("inconsistent linkage for `%s' previously declared at %w\n", p->name, &p->src); } if (p == NULL || p->scope != GLOBAL) { Symbol q = lookup(id, externals); if (q) { if (sclass == STATIC || !eqtype(ty, q->type, 1)) warning("declaration of `%s' does not match previous declaration at %w\n", id, &q->src); p = relocate(id, externals, globals); p->sclass = sclass; } else { p = install(id, &globals, GLOBAL, PERM); p->sclass = sclass; (*IR->defsymbol)(p); } if (p->sclass != STATIC) { static int nglobals; nglobals++; if (Aflag >= 2 && nglobals == 512) warning("more than 511 external identifiers\n"); } } else if (p->sclass == EXTERN) p->sclass = sclass; p->type = ty; p->src = *pos; if (t == '=' && isfunc(p->type)) { error("illegal initialization for `%s'\n", p->name); t = gettok(); initializer(p->type, 0); } else if (t == '=') { initglobal(p, 0); if (glevel > 0 && IR->stabsym) { (*IR->stabsym)(p); swtoseg(p->u.seg); } } else if (p->sclass == STATIC && !isfunc(p->type) && p->type->size == 0) error("undefined size for `%t %s'\n", p->type, p->name); return p; }

Here is the call graph for this function:

Symbol dcllocal (  int  , char *  , Type  , Coordinate *  )  [static]

Definition at line 920 of file decl.c. References symbol::alias, append(), array(), asgn(), assert, autos, BSS, compose(), CONST, Coordinate, defglobal(), symbol::defined, definept(), interface::defsymbol, e, eqtype(), error(), expect(), expr1(), EXTERN, externals, FUNC, genident(), gettok(), GLOBAL, globals, identifiers, idtree(), initglobal(), install(), IR, isarray, isconst, isfunc, isscalar, isstruct, isvolatile, level, LOCAL, lookup(), symbol::name, NULL, p, PARAM, PERM, q, qual(), symbol::ref, regcount, registers, root(), symbol::sclass, symbol::scope, type::size, interface::space, symbol::src, Symbol, t, Tree, type::type, symbol::type, Type, symbol::u, walk(), and warning(). Referenced by compound(). { Symbol p, q; if (sclass == 0) sclass = isfunc(ty) ? EXTERN : AUTO; else if (isfunc(ty) && sclass != EXTERN) { error("invalid storage class `%k' for `%t %s'\n", sclass, ty, id); sclass = EXTERN; } else if (sclass == REGISTER && (isvolatile(ty) || isstruct(ty) || isarray(ty))) { warning("register declaration ignored for `%t %s'\n", ty, id); sclass = AUTO; } q = lookup(id, identifiers); if (q && q->scope >= level || q && q->scope == PARAM && level == LOCAL) if (sclass == EXTERN && q->sclass == EXTERN && eqtype(q->type, ty, 1)) ty = compose(ty, q->type); else error("redeclaration of `%s' previously declared at %w\n", q->name, &q->src); assert(level >= LOCAL); p = install(id, &identifiers, level, sclass == STATIC || sclass == EXTERN ? PERM : FUNC); p->type = ty; p->sclass = sclass; p->src = *pos; switch (sclass) { case EXTERN: q = lookup(id, globals); if (q == NULL || q->sclass == TYPEDEF || q->sclass == ENUM) { q = lookup(id, externals); if (q == NULL) { q = install(p->name, &externals, GLOBAL, PERM); q->type = p->type; q->sclass = EXTERN; q->src = src; (*IR->defsymbol)(q); } } if (!eqtype(p->type, q->type, 1)) warning("declaration of `%s' does not match previous declaration at %w\n", q->name, &q->src); p->u.alias = q; break; case STATIC: (*IR->defsymbol)(p); initglobal(p, 0); if (!p->defined) if (p->type->size > 0) { defglobal(p, BSS); (*IR->space)(p->type->size); } else error("undefined size for `%t %s'\n", p->type, p->name); p->defined = 1; break; case REGISTER: registers = append(p, registers); regcount++; p->defined = 1; break; case AUTO: autos = append(p, autos); p->defined = 1; break; default: assert(0); } if (t == '=') { Tree e; if (sclass == EXTERN) error("illegal initialization of `extern %s'\n", id); t = gettok(); definept(NULL); if (isscalar(p->type) || isstruct(p->type) && t != '{') { if (t == '{') { t = gettok(); e = expr1(0); expect('}'); } else e = expr1(0); } else { Symbol t1; Type ty = p->type, ty1 = ty; while (isarray(ty1)) ty1 = ty1->type; if (!isconst(ty) && (!isarray(ty) || !isconst(ty1))) ty = qual(CONST, ty); t1 = genident(STATIC, ty, GLOBAL); initglobal(t1, 1); if (isarray(p->type) && p->type->size == 0 && t1->type->size > 0) p->type = array(p->type->type, t1->type->size/t1->type->type->size, 0); e = idtree(t1); } walk(root(asgn(p, e)), 0, 0); p->ref = 1; } if (!isfunc(p->type) && p->defined && p->type->size <= 0) error("undefined size for `%t %s'\n", p->type, id); return p; }

Here is the call graph for this function:

Symbol dclparam (  int  , char *  , Type  , Coordinate *  )  [static]

Definition at line 479 of file decl.c. References atop(), Coordinate, symbol::defined, error(), expr1(), FUNC, gettok(), identifiers, install(), isarray, isfunc, isstruct, isvolatile, level, lookup(), p, ptr(), symbol::sclass, symbol::scope, symbol::src, stringf(), Symbol, t, symbol::type, Type, and warning(). Referenced by funcdefn(), and parameters(). { Symbol p; if (isfunc(ty)) ty = ptr(ty); else if (isarray(ty)) ty = atop(ty); if (sclass == 0) sclass = AUTO; else if (sclass != REGISTER) { error("invalid storage class `%k' for `%t%s\n", sclass, ty, stringf(id ? " %s'" : "' parameter", id)); sclass = AUTO; } else if (isvolatile(ty) || isstruct(ty)) { warning("register declaration ignored for `%t%s\n", ty, stringf(id ? " %s'" : "' parameter", id)); sclass = AUTO; } p = lookup(id, identifiers); if (p && p->scope == level) error("duplicate declaration for `%s' previously declared at %w\n", id, &p->src); else p = install(id, &identifiers, level, FUNC); p->sclass = sclass; p->src = *pos; p->type = ty; p->defined = 1; if (t == '=') { error("illegal initialization for parameter `%s'\n", id); t = gettok(); (void)expr1(0); } return p; }

Here is the call graph for this function:

Type dclr (  Type  , char **  , Symbol **  , int  )  [static]

Definition at line 293 of file decl.c. References Aflag, array(), ARRAY, assert, CONST, dclr1(), type::f, func(), FUNCTION, type::oldstyle, type::op, params, POINTER, type::proto, ptr(), qual(), type::size, Symbol, type::type, Type, type::u, VOLATILE, and warning(). Referenced by decl(), parameters(), and typename(). { Type ty = dclr1(id, params, abstract); for ( ; ty; ty = ty->type) switch (ty->op) { case POINTER: basety = ptr(basety); break; case FUNCTION: basety = func(basety, ty->u.f.proto, ty->u.f.oldstyle); break; case ARRAY: basety = array(basety, ty->size, 0); break; case CONST: case VOLATILE: basety = qual(ty->op, basety); break; default: assert(0); } if (Aflag >= 2 && basety->size > 32767) warning("more than 32767 bytes in `%t'\n", basety); return basety; }

Here is the call graph for this function:

Type dclr1 (  char **  , Symbol **  , int  )  [static]

Definition at line 325 of file decl.c. References ARRAY, assert, CONST, enterscope(), error(), exitparams(), expect(), FUNCTION, gettok(), ID, intexpr(), istypename, kind, level, n, NULL, parameters(), params, POINTER, type::size, Symbol, t, tnode(), tsym, type::type, and Type. Referenced by dclr(). { Type ty = NULL; switch (t) { case ID: if (id) *id = token; else error("extraneous identifier `%s'\n", token); t = gettok(); break; case '*': t = gettok(); if (t == CONST || t == VOLATILE) { Type ty1; ty1 = ty = tnode(t, NULL); while ((t = gettok()) == CONST || t == VOLATILE) ty1 = tnode(t, ty1); ty->type = dclr1(id, params, abstract); ty = ty1; } else ty = dclr1(id, params, abstract); ty = tnode(POINTER, ty); break; case '(': t = gettok(); if (abstract && (t == REGISTER || istypename(t, tsym) || t == ')')) { Symbol *args; ty = tnode(FUNCTION, ty); enterscope(); if (level > PARAM) enterscope(); args = parameters(ty); exitparams(args); } else { ty = dclr1(id, params, abstract); expect(')'); if (abstract && ty == NULL && (id == NULL || *id == NULL)) return tnode(FUNCTION, NULL); } break; case '[': break; default: return ty; } while (t == '(' || t == '[') switch (t) { case '(': t = gettok(); { Symbol *args; ty = tnode(FUNCTION, ty); enterscope(); if (level > PARAM) enterscope(); args = parameters(ty); if (params && *params == NULL) *params = args; else exitparams(args); } break; case '[': t = gettok(); { int n = 0; if (kind[t] == ID) { n = intexpr(']', 1); if (n <= 0) { error("`%d' is an illegal array size\n", n); n = 1; } } else expect(']'); ty = tnode(ARRAY, ty); ty->size = n; } break; default: assert(0); } return ty; }

Here is the call graph for this function:

void decl (  Symbol(*)(int, char *, Type, Coordinate *)   )  [static]

Definition at line 143 of file decl.c. References Aflag, Coordinate, dclr(), error(), exitparams(), exitscope(), type::f, FUNC, funcdefn(), gettok(), hasproto(), ID, identifiers, install(), isenum, isfunc, isstruct, istypename, kind, level, LOCAL, lookup(), NULL, type::oldstyle, p, params, PERM, symbol::sclass, symbol::scope, specifier(), symbol::src, Symbol, t, test(), tsym, symbol::type, Type, type::u, unqual, and warning(). Referenced by compound(), funcdefn(), and program(). { int sclass; Type ty, ty1; static char stop[] = { CHAR, STATIC, ID, 0 }; ty = specifier(&sclass); if (t == ID || t == '*' || t == '(' || t == '[') { char *id; Coordinate pos; id = NULL; pos = src; if (level == GLOBAL) { Symbol *params = NULL; ty1 = dclr(ty, &id, &params, 0); if (params && id && isfunc(ty1) && (t == '{' || istypename(t, tsym) || (kind[t] == STATIC && t != TYPEDEF))) { if (sclass == TYPEDEF) { error("invalid use of `typedef'\n"); sclass = EXTERN; } if (ty1->u.f.oldstyle) exitscope(); funcdefn(sclass, id, ty1, params, pos); return; } else if (params) exitparams(params); } else ty1 = dclr(ty, &id, NULL, 0); for (;;) { if (Aflag >= 1 && !hasproto(ty1)) warning("missing prototype\n"); if (id == NULL) error("missing identifier\n"); else if (sclass == TYPEDEF) { Symbol p = lookup(id, identifiers); if (p && p->scope == level) error("redeclaration of `%s'\n", id); p = install(id, &identifiers, level, level < LOCAL ? PERM : FUNC); p->type = ty1; p->sclass = TYPEDEF; p->src = pos; } else (void)(*dcl)(sclass, id, ty1, &pos); if (t != ',') break; t = gettok(); id = NULL; pos = src; ty1 = dclr(ty, &id, NULL, 0); } } else if (ty == NULL || !(isenum(ty) || isstruct(ty) && (*unqual(ty)->u.sym->name < '1' || *unqual(ty)->u.sym->name > '9'))) error("empty declaration\n"); test(';', stop); }

Here is the call graph for this function:

void defglobal (  Symbol  p, int  seg )

Definition at line 284 of file decl.c. References symbol::defined, interface::export, interface::global, IR, p, symbol::sclass, symbol::seg, swtoseg(), Symbol, and symbol::u. Referenced by bbcall(), bbfunc(), bbvars(), dcllocal(), doconst(), doglobal(), emitcode(), initglobal(), and tracecall(). { p->u.seg = seg; swtoseg(p->u.seg); if (p->sclass != STATIC) (*IR->export)(p); (*IR->global)(p); p->defined = 1; }

Here is the call graph for this function:

void doconst (  Symbol  , void *  )

Definition at line 1052 of file decl.c. References assert, symbol::c, interface::defconst, defglobal(), interface::defstring, IR, isarray, LIT, symbol::loc, n, type::op, value::p, p, s, symbol::seg, type::size, Symbol, type::type, symbol::type, value::u, symbol::u, v, symbol::v, Value, and widechar. Referenced by finalize(). { if (p->u.c.loc) { assert(p->u.c.loc->u.seg == 0); defglobal(p->u.c.loc, LIT); if (isarray(p->type) && p->type->type == widechar) { unsigned int *s = p->u.c.v.p; int n = p->type->size/widechar->size; while (n-- > 0) { Value v; v.u = *s++; (*IR->defconst)(widechar->op, widechar->size, v); } } else if (isarray(p->type)) (*IR->defstring)(p->type->size, p->u.c.v.