/*-----------------------------------------------------------------*/
int
allocVariables (symbol * symChain)
{
symbol *sym;
symbol *csym;
int stack = 0;
int saveLevel = 0;
/* go thru the symbol chain */
for (sym = symChain; sym; sym = sym->next)
{
/* if this is a typedef then add it */
/* to the typedef table */
if (IS_TYPEDEF (sym->etype))
{
/* check if the typedef already exists */
csym = findSym (TypedefTab, NULL, sym->name);
if (csym && csym->level == sym->level)
werror (E_DUPLICATE_TYPEDEF, sym->name);
SPEC_EXTR (sym->etype) = 0;
addSym (TypedefTab, sym, sym->name, sym->level, sym->block, 0);
continue; /* go to the next one */
}
/* make sure it already exists */
csym = findSymWithLevel (SymbolTab, sym);
if (!csym || (csym && csym->level != sym->level))
csym = sym;
/* check the declaration */
checkDecl (csym, 0);
/* if this is a function or a pointer to a */
/* function then do args processing */
if (funcInChain (csym->type))
{
processFuncArgs (csym);
}
/* if this is an extern variable then change */
/* the level to zero temporarily */
if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type))
{
saveLevel = csym->level;
csym->level = 0;
}
/* if this is a literal then it is an enumerated */
/* type so need not allocate it space for it */
if (IS_LITERAL (sym->etype))
continue;
/* generate the actual declaration */
if (csym->level)
{
allocLocal (csym);
if (csym->onStack)
stack += getSize (csym->type);
}
else
allocGlobal (csym);
/* restore the level */
if (IS_EXTERN (csym->etype) || IS_FUNC (csym->type))
csym->level = saveLevel;
}
return stack;
}
/*
* pp_add_spec_to_decl() - Add the specifier to each of the declarators in
* decl_chain. This is accomplished by cloning p_spec and then tacking it
* onto the end of every declaration chain in decl_chain.
* return : void
* p_spec(in): A pointer to a specifier/declarator chain created by a previous
* typedef, or to a single specifier. It is cloned and then tacked onto
* the end of every declaration chain in the list pointed to by decl_chain.
* decl_chain(out): A chain of declarators, each of which is to receive the
* p_spec specifier.
*/
void
pp_add_spec_to_decl (LINK * p_spec, SYMBOL * decl_chain)
{
LINK *clone_start, *clone_end;
for (; decl_chain; decl_chain = decl_chain->next)
{
clone_start = pp_clone_type (p_spec, &clone_end);
if (clone_start == NULL)
{
esql_yyverror (pp_get_msg (EX_DECL_SET, MSG_MALFORMED_CHAIN));
exit (1);
}
if (IS_PSEUDO_TYPE (clone_start)
&& clone_start->decl.s.val.v_struct == NULL)
{
LINK *old_etype;
char tmp[32];
old_etype = decl_chain->etype;
if (old_etype == NULL
|| (IS_VAR_TYPE (clone_start) && IS_ARRAY (old_etype) == 0))
{
esql_yyverror (pp_get_msg (EX_DECL_SET, MSG_BAD_PSEUDO_DECL),
pp_type_str (clone_start));
exit (1);
}
clone_start->decl.s.val.v_struct =
pp_new_pseudo_def (clone_start->decl.s.noun,
old_etype->decl.d.num_ele);
if (clone_start->decl.s.noun == N_VARCHAR)
{
sprintf (tmp, " = { %s, \"\" }", old_etype->decl.d.num_ele);
}
else
{
sprintf (tmp, " = { ((%s)+7)/8, \"\" }",
old_etype->decl.d.num_ele);
}
decl_chain->args = pp_new_symbol (tmp, decl_chain->level);
pp_discard_link (old_etype);
if (decl_chain->type == old_etype)
{
decl_chain->type = NULL;
}
else
{
LINK *parent;
for (parent = decl_chain->type;
parent->next != old_etype; parent = parent->next)
{
;
}
parent->next = NULL;
decl_chain->etype = parent;
}
}
if (decl_chain->type == NULL) /* No declarators */
{
decl_chain->type = clone_start;
}
else
{
decl_chain->etype->next = clone_start;
}
decl_chain->etype = clone_end;
/*
* If the declaration we're looking at is really a typedef,
* record the symbol itself within the specifier. This will
* make it easier to point back to the symbol from other
* declarations, which will make it easier to print out
* later declarations using the typedef name rather than its
* expansion.
*/
if (IS_TYPEDEF (clone_end))
{
pp_set_class_bit (0, clone_end);
decl_chain->type->tdef = decl_chain;
decl_chain->type->from_tdef = decl_chain;
}
}
}
