symtab_t *
symtab_flat_copy (symtab_t *symtab, symtab_t *parent)
{
symtab_t *newtab;
symbol_t *newsym;
symbol_t *symbol;
newtab = new_symtab (parent, stab_local);
do {
for (symbol = symtab->symbols; symbol; symbol = symbol->next) {
if (Hash_Find (newtab->tab, symbol->name))
continue;
newsym = copy_symbol (symbol);
symtab_addsymbol (newtab, newsym);
}
symtab = symtab->parent;
// Set the tail pointer so symbols in ancestor tables come before
// those in decendent tables.
newtab->symtail = &newtab->symbols;
} while (symtab);
// Reset the tail pointer so any symbols added to newtab come after
// those copied from the input symbol table chain.
for (symbol = newtab->symbols; symbol && symbol->next;
symbol = symbol->next)
;
newtab->symtail = symbol ? &symbol->next : &newtab->symbols;
return newtab;
}
TOKEN declaration(SYMBOL s)
{
TOKEN t = NULL;
TOKEN dec = NULL;
s->kind = VARSYM; //if we have made it this far, i think it's safe to assume we are declaring a variable
declaration_specifiers(s);
dec = init_declarator_list(s);
t = peek_token();
if(false == token_matches_delimiter(t, SEMICOLON))
{
//it turns out that we haven't found a variable declaration, so exit
//and allow the function definition recognizer take a stab at parsing
dec = NULL;
}
else
{
t = get_token(); //consume the SEMICOLON
SYMBOL entry = searchins(s->namestring);
copy_symbol(s, entry);
}
return dec;
}
void simple_format
( MPL *mpl,
SET *set, /* not changed */
MEMBER *memb, /* modified */
SLICE *slice /* not changed */
)
{ TUPLE *tuple;
SLICE *temp;
SYMBOL *sym, *with = NULL;
insist(set != NULL);
insist(memb != NULL);
insist(slice != NULL);
insist(set->dimen == slice_dimen(mpl, slice));
insist(memb->value.set->dim == set->dimen);
if (slice_arity(mpl, slice) > 0) insist(is_symbol(mpl));
/* read symbols and construct complete n-tuple */
tuple = create_tuple(mpl);
for (temp = slice; temp != NULL; temp = temp->next)
{ if (temp->sym == NULL)
{ /* substitution is needed; read symbol */
if (!is_symbol(mpl))
{ int lack = slice_arity(mpl, temp);
/* with cannot be null due to assertion above */
insist(with != NULL);
if (lack == 1)
error(mpl, "one item missing in data group beginning "
"with %s", format_symbol(mpl, with));
else
error(mpl, "%d items missing in data group beginning "
"with %s", lack, format_symbol(mpl, with));
}
sym = read_symbol(mpl);
if (with == NULL) with = sym;
}
else
{ /* copy symbol from the slice */
sym = copy_symbol(mpl, temp->sym);
}
/* append the symbol to the n-tuple */
tuple = expand_tuple(mpl, tuple, sym);
/* skip optional comma *between* <symbols> */
if (temp->next != NULL && mpl->token == T_COMMA)
get_token(mpl /* , */);
}
/* add constructed n-tuple to elemental set */
check_then_add(mpl, memb->value.set, tuple);
return;
}
void plain_format
( MPL *mpl,
PARAMETER *par, /* not changed */
SLICE *slice /* not changed */
)
{ TUPLE *tuple;
SLICE *temp;
SYMBOL *sym, *with = NULL;
insist(par != NULL);
insist(par->dim == slice_dimen(mpl, slice));
insist(is_symbol(mpl));
/* read symbols and construct complete subscript list */
tuple = create_tuple(mpl);
for (temp = slice; temp != NULL; temp = temp->next)
{ if (temp->sym == NULL)
{ /* substitution is needed; read symbol */
if (!is_symbol(mpl))
{ int lack = slice_arity(mpl, temp) + 1;
insist(with != NULL);
insist(lack > 1);
error(mpl, "%d items missing in data group beginning wit"
"h %s", lack, format_symbol(mpl, with));
}
sym = read_symbol(mpl);
if (with == NULL) with = sym;
}
else
{ /* copy symbol from the slice */
sym = copy_symbol(mpl, temp->sym);
}
/* append the symbol to the subscript list */
tuple = expand_tuple(mpl, tuple, sym);
/* skip optional comma */
if (mpl->token == T_COMMA) get_token(mpl /* , */);
}
/* read value and assign it to new parameter member */
if (!is_symbol(mpl))
{ insist(with != NULL);
error(mpl, "one item missing in data group beginning with %s",
format_symbol(mpl, with));
}
read_value(mpl, par, tuple);
return;
}
void tabbing_format
( MPL *mpl,
SYMBOL *altval /* not changed */
)
{ SET *set = NULL;
PARAMETER *par;
SLICE *list, *col;
TUPLE *tuple;
int next_token, j, dim = 0;
char *last_name = NULL;
/* read the optional <prefix> */
if (is_symbol(mpl))
{ get_token(mpl /* <symbol> */);
next_token = mpl->token;
unget_token(mpl /* <symbol> */);
if (next_token == T_COLON)
{ /* select the set to saturate it with data */
set = select_set(mpl, mpl->image);
/* the set must be simple (i.e. not set of sets) */
if (set->dim != 0)
error(mpl, "%s must be a simple set", set->name);
/* and must not be defined yet */
if (set->array->head != NULL)
error(mpl, "%s already defined", set->name);
/* add new (the only) member to the set and assign it empty
elemental set */
add_member(mpl, set->array, NULL)->value.set =
create_elemset(mpl, set->dimen);
last_name = set->name, dim = set->dimen;
get_token(mpl /* <symbol> */);
insist(mpl->token == T_COLON);
get_token(mpl /* : */);
}
}
/* read the table heading that contains parameter names */
list = create_slice(mpl);
while (mpl->token != T_ASSIGN)
{ /* there must be symbolic name of parameter */
if (!is_symbol(mpl))
error(mpl, "parameter name or := missing where expected");
/* select the parameter to saturate it with data */
par = select_parameter(mpl, mpl->image);
/* the parameter must be subscripted */
if (par->dim == 0)
error(mpl, "%s not a subscripted parameter", mpl->image);
/* the set (if specified) and all the parameters in the data
block must have identical dimension */
if (dim != 0 && par->dim != dim)
{ insist(last_name != NULL);
error(mpl, "%s has dimension %d while %s has dimension %d",
last_name, dim, par->name, par->dim);
}
/* set default value for the parameter (if specified) */
if (altval != NULL)
set_default(mpl, par, copy_symbol(mpl, altval));
/* append the parameter to the column list */
list = expand_slice(mpl, list, (SYMBOL *)par);
last_name = par->name, dim = par->dim;
get_token(mpl /* <symbol> */);
/* skip optional comma */
if (mpl->token == T_COMMA) get_token(mpl /* , */);
}
if (slice_dimen(mpl, list) == 0)
error(mpl, "at least one parameter name required");
get_token(mpl /* := */);
/* skip optional comma */
if (mpl->token == T_COMMA) get_token(mpl /* , */);
/* read rows that contain tabbing data */
while (is_symbol(mpl))
{ /* read subscript list */
tuple = create_tuple(mpl);
for (j = 1; j <= dim; j++)
{ /* read j-th subscript */
if (!is_symbol(mpl))
{ int lack = slice_dimen(mpl, list) + dim - j + 1;
insist(tuple != NULL);
insist(lack > 1);
error(mpl, "%d items missing in data group beginning wit"
"h %s", lack, format_symbol(mpl, tuple->sym));
}
/* read and append j-th subscript to the n-tuple */
tuple = expand_tuple(mpl, tuple, read_symbol(mpl));
/* skip optional comma *between* <symbols> */
if (j < dim && mpl->token == T_COMMA)
get_token(mpl /* , */);
}
/* if the set is specified, add to it new n-tuple, which is a
copy of the subscript list just read */
if (set != NULL)
check_then_add(mpl, set->array->head->value.set,
copy_tuple(mpl, tuple));
/* skip optional comma between <symbol> and <value> */
if (mpl->token == T_COMMA) get_token(mpl /* , */);
/* read values accordingly to the column list */
for (col = list; col != NULL; col = col->next)
{ /* if the token is single point, no value is provided */
if (is_literal(mpl, "."))
{ get_token(mpl /* . */);
continue;
}
/* read value and assign it to new parameter member */
if (!is_symbol(mpl))
{ int lack = slice_dimen(mpl, col);
insist(tuple != NULL);
if (lack == 1)
error(mpl, "one item missing in data group beginning "
"with %s", format_symbol(mpl, tuple->sym));
else
error(mpl, "%d items missing in data group beginning "
"with %s", lack, format_symbol(mpl, tuple->sym));
}
read_value(mpl, (PARAMETER *)col->sym, copy_tuple(mpl,
tuple));
/* skip optional comma preceding the next value */
if (col->next != NULL && mpl->token == T_COMMA)
get_token(mpl /* , */);
}
/* delete the original subscript list */
delete_tuple(mpl, tuple);
/* skip optional comma (only if there is next data group) */
if (mpl->token == T_COMMA)
{ get_token(mpl /* , */);
if (!is_symbol(mpl)) unget_token(mpl /* , */);
}
}
/* delete the column list (it contains parameters, not symbols,
so nullify it before) */
for (col = list; col != NULL; col = col->next) col->sym = NULL;
delete_slice(mpl, list);
return;
}
void tabular_format
( MPL *mpl,
PARAMETER *par, /* not changed */
SLICE *slice, /* not changed */
int tr
)
{ SLICE *list, *col, *temp;
TUPLE *tuple;
SYMBOL *row;
insist(par != NULL);
insist(par->dim == slice_dimen(mpl, slice));
insist(slice_arity(mpl, slice) == 2);
/* read the table heading that contains column symbols (the table
may have no columns) */
list = create_slice(mpl);
while (mpl->token != T_ASSIGN)
{ /* read column symbol and append it to the column list */
if (!is_symbol(mpl))
error(mpl, "number, symbol, or := missing where expected");
list = expand_slice(mpl, list, read_symbol(mpl));
}
get_token(mpl /* := */);
/* read zero or more rows that contain tabular data */
while (is_symbol(mpl))
{ /* read row symbol (if the table has no columns, these symbols
are just ignored) */
row = read_symbol(mpl);
/* read values accordingly to the column list */
for (col = list; col != NULL; col = col->next)
{ int which = 0;
/* if the token is single point, no value is provided */
if (is_literal(mpl, "."))
{ get_token(mpl /* . */);
continue;
}
/* construct complete subscript list */
tuple = create_tuple(mpl);
for (temp = slice; temp != NULL; temp = temp->next)
{ if (temp->sym == NULL)
{ /* substitution is needed */
switch (++which)
{ case 1:
/* substitute in the first null position */
tuple = expand_tuple(mpl, tuple,
copy_symbol(mpl, tr ? col->sym : row));
break;
case 2:
/* substitute in the second null position */
tuple = expand_tuple(mpl, tuple,
copy_symbol(mpl, tr ? row : col->sym));
break;
default:
insist(which != which);
}
}
else
{ /* copy symbol from the slice */
tuple = expand_tuple(mpl, tuple, copy_symbol(mpl,
temp->sym));
}
}
insist(which == 2);
/* read value and assign it to new parameter member */
if (!is_symbol(mpl))
{ int lack = slice_dimen(mpl, col);
if (lack == 1)
error(mpl, "one item missing in data group beginning "
"with %s", format_symbol(mpl, row));
else
error(mpl, "%d items missing in data group beginning "
"with %s", lack, format_symbol(mpl, row));
}
read_value(mpl, par, tuple);
}
/* delete the row symbol */
delete_symbol(mpl, row);
}
/* delete the column list */
delete_slice(mpl, list);
return;
}
void matrix_format
( MPL *mpl,
SET *set, /* not changed */
MEMBER *memb, /* modified */
SLICE *slice, /* not changed */
int tr
)
{ SLICE *list, *col, *temp;
TUPLE *tuple;
SYMBOL *row;
insist(set != NULL);
insist(memb != NULL);
insist(slice != NULL);
insist(set->dimen == slice_dimen(mpl, slice));
insist(memb->value.set->dim == set->dimen);
insist(slice_arity(mpl, slice) == 2);
/* read the matrix heading that contains column symbols (there
may be no columns at all) */
list = create_slice(mpl);
while (mpl->token != T_ASSIGN)
{ /* read column symbol and append it to the column list */
if (!is_symbol(mpl))
error(mpl, "number, symbol, or := missing where expected");
list = expand_slice(mpl, list, read_symbol(mpl));
}
get_token(mpl /* := */);
/* read zero or more rows that contain matrix data */
while (is_symbol(mpl))
{ /* read row symbol (if the matrix has no columns, row symbols
are just ignored) */
row = read_symbol(mpl);
/* read the matrix row accordingly to the column list */
for (col = list; col != NULL; col = col->next)
{ int which = 0;
/* check indicator */
if (is_literal(mpl, "+"))
;
else if (is_literal(mpl, "-"))
{ get_token(mpl /* - */);
continue;
}
else
{ int lack = slice_dimen(mpl, col);
if (lack == 1)
error(mpl, "one item missing in data group beginning "
"with %s", format_symbol(mpl, row));
else
error(mpl, "%d items missing in data group beginning "
"with %s", lack, format_symbol(mpl, row));
}
/* construct complete n-tuple */
tuple = create_tuple(mpl);
for (temp = slice; temp != NULL; temp = temp->next)
{ if (temp->sym == NULL)
{ /* substitution is needed */
switch (++which)
{ case 1:
/* substitute in the first null position */
tuple = expand_tuple(mpl, tuple,
copy_symbol(mpl, tr ? col->sym : row));
break;
case 2:
/* substitute in the second null position */
tuple = expand_tuple(mpl, tuple,
copy_symbol(mpl, tr ? row : col->sym));
break;
default:
insist(which != which);
}
}
else
{ /* copy symbol from the slice */
tuple = expand_tuple(mpl, tuple, copy_symbol(mpl,
temp->sym));
}
}
insist(which == 2);
/* add constructed n-tuple to elemental set */
check_then_add(mpl, memb->value.set, tuple);
get_token(mpl /* + */);
}
/* delete the row symbol */
delete_symbol(mpl, row);
}
/* delete the column list */
delete_slice(mpl, list);
return;
}
static int
_elf_nlist(Elf *elf, struct nlist *nl) {
unsigned first[PRIME];
Elf_Scn *symtab = NULL;
Elf_Scn *strtab = NULL;
Elf_Data *symdata;
Elf_Data *strdata;
size_t symsize;
size_t nsymbols;
const char *name;
struct hash *table;
unsigned long hash;
unsigned i;
struct nlist *np;
/*
* Get and translate ELF header, section table and so on.
* Must be class independent, so don't use elf32_get*().
*/
if (elf->e_kind != ELF_K_ELF) {
return -1;
}
if (!elf->e_ehdr && !_elf_cook(elf)) {
return -1;
}
/*
* Find symbol table. If there is none, try dynamic symbols.
*/
for (symtab = elf->e_scn_1; symtab; symtab = symtab->s_link) {
if (symtab->s_type == SHT_SYMTAB) {
break;
}
if (symtab->s_type == SHT_DYNSYM) {
strtab = symtab;
}
}
if (!symtab && !(symtab = strtab)) {
return -1;
}
/*
* Get associated string table.
*/
i = 0;
if (elf->e_class == ELFCLASS32) {
i = symtab->s_shdr32.sh_link;
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
i = symtab->s_shdr64.sh_link;
}
#endif /* __LIBELF64 */
if (i == 0) {
return -1;
}
for (strtab = elf->e_scn_1; strtab; strtab = strtab->s_link) {
if (strtab->s_index == i) {
break;
}
}
if (!strtab || strtab->s_type != SHT_STRTAB) {
return -1;
}
/*
* Get and translate section data.
*/
symdata = elf_getdata(symtab, NULL);
strdata = elf_getdata(strtab, NULL);
if (!symdata || !strdata) {
return -1;
}
symsize = _msize(elf->e_class, _elf_version, ELF_T_SYM);
elf_assert(symsize);
nsymbols = symdata->d_size / symsize;
if (!symdata->d_buf || !strdata->d_buf || !nsymbols || !strdata->d_size) {
return -1;
}
/*
* Build a simple hash table.
*/
if (!(table = (struct hash*)malloc(nsymbols * sizeof(*table)))) {
return -1;
}
for (i = 0; i < PRIME; i++) {
first[i] = 0;
}
for (i = 0; i < nsymbols; i++) {
table[i].name = NULL;
table[i].hash = 0;
table[i].next = 0;
}
for (i = 1; i < nsymbols; i++) {
name = symbol_name(elf, symdata->d_buf, strdata->d_buf,
strdata->d_size, i);
if (name == NULL) {
free(table);
return -1;
}
if (*name != '\0') {
table[i].name = name;
table[i].hash = elf_hash((unsigned char *) name);
hash = table[i].hash % PRIME;
table[i].next = first[hash];
first[hash] = i;
}
}
/*
* Lookup symbols, one by one.
*/
for (np = nl; (name = np->n_name) && *name; np++) {
hash = elf_hash((unsigned char *) name);
for (i = first[hash % PRIME]; i; i = table[i].next) {
if (table[i].hash == hash && !strcmp(table[i].name, name)) {
break;
}
}
if (i) {
copy_symbol(elf, np, symdata->d_buf, i);
}
else {
np->n_value = 0;
np->n_scnum = 0;
np->n_type = 0;
np->n_sclass = 0;
np->n_numaux = 0;
}
}
free(table);
return 0;
}
