void delete_symbol(const char *name) {
struct symbol *s;
if((s = remove_symbol(symbol_table, name))) {
free((void *) s->decl);
free(s);
}
}
static void
fake_up_certain_popular_kernel_symbols(void)
{
kstat_ctl_t *kc;
kstat_t *ksp;
char *name;
if ((kc = kstat_open()) == NULL)
return;
for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
if (strcmp(ksp->ks_module, "cpu_info") == 0) {
if ((name = malloc(20)) == NULL)
break;
/*
* For consistency, keep cpu[0] and toss cpu0
* or any other such symbols.
*/
if (ksp->ks_instance == 0)
remove_symbol((uintptr_t)ksp->ks_private);
(void) sprintf(name, "cpu[%d]", ksp->ks_instance);
add_symbol(name, (uintptr_t)ksp->ks_private,
sizeof (struct cpu));
}
}
(void) kstat_close(kc);
}
void destroy_sorted_symbols(void) {
sortedSymbol* ssym = sortedSyms->first;
while (ssym != NULL) {
remove_symbol(ssym->sym);
sortedSymbol* temp = ssym;
ssym = ssym->next;
free(temp);
}
sortedSyms->size = 0;
sortedSyms->first = NULL;
}
void add_symbol(const char *name, void *addr, const char *decl) {
if(!addr) return;
struct symbol *s;
if((s = remove_symbol(symbol_table, name))) {
fprintf(stderr, "Warning: '%s' redeclared as '%s'\n", s->decl, decl);
free((void *) s->decl);
free(s);
}
s = malloc(sizeof(struct symbol));
s->name = strdup(name);
s->addr = addr;
s->decl = strdup(decl);
insert_symbol(symbol_table, s->name, s);
}
void update_frequency(symbol *r, int c){
/*
update_frequency() - given the root of a symbol table-tree and a character,
increases the frequency of that character in the symbol table-tree,
creating nodes as necessary.
*/
symbol *s;
if (!exists_symbol(r,c))
s=init_symbol(c);
else
s=remove_symbol(r,c);
s->frequency++;
insert_symbol(r,s);
}
memptr func_defun(memptr func_expr) {
if (num_nodes(func_expr) != 4) {
#ifdef DEBUG
printf("25\n");
#endif
ERROR(ERROR_DEFUN, ERROR_FAILURE, ERROR_INVALID, ERROR_COUNT);
return NOT_FOUND;
}
memptr name = cons_pool[cons_pool[func_expr].cdr].car;
if (cons_pool[name].carKind != STRING || cons_pool[name].cdrKind != CONS) {
// first argument not a name
#ifdef DEBUG
printf("26\n");
#endif
ERROR(ERROR_DEFUN, ERROR_FAILURE, ERROR_INVALID, ERROR_MALFORMED);
return NOT_FOUND;
}
memptr parameters = cons_pool[cons_pool[cons_pool[func_expr].cdr].cdr].car;
if (parameters != nil) {
if (cons_pool[parameters].carKind != CONS
|| cons_pool[parameters].cdrKind != NIL) {
// second argument not a parameters list
#ifdef DEBUG
printf("27\n");
#endif
ERROR(ERROR_DEFUN, ERROR_FAILURE, ERROR_INVALID, ERROR_MALFORMED);
return NOT_FOUND;
}
memptr current_param_node, next_param_node = cons_pool[parameters].car,
current_param;
// function has parameter(s)
do {
current_param_node = next_param_node;
current_param = cons_pool[current_param_node].car;
if (cons_pool[current_param].carKind != STRING
|| cons_pool[current_param].cdrKind != CONS) {
// a parameter is not a name
#ifdef DEBUG
printf("28\n");
#endif
ERROR(ERROR_DEFUN, ERROR_FAILURE, ERROR_INVALID, ERROR_MALFORMED);
return NOT_FOUND;
}
next_param_node = cons_pool[next_param_node].cdr;
} while (cons_pool[current_param_node].cdrKind == CONS);
}
// now we can build the function representation in the memory pool,
// and connect the functions name to it
memptr function = safe_allocate_cons(), current;
cons_pool[function].car = cons_pool[name].car;
cons_pool[function].carKind = STRING;
cons_pool[function].cdr = allocate_cons();
cons_pool[function].cdrKind = CONS;
// the name value - a user function
current = cons_pool[function].cdr;
cons_pool[current].car = allocate_cons();
cons_pool[current].carKind = CONS;
cons_pool[current].cdrKind = NIL;
// first argument - parameters list
current = cons_pool[current].car;
cons_pool[current].car = (
parameters == nil ? nil : cons_pool[parameters].car);
cons_pool[current].carKind = CONS;
cons_pool[current].cdr = allocate_cons();
cons_pool[current].cdrKind = CONS;
// second argument - function body
current = cons_pool[current].cdr;
cons_pool[current].carKind = CONS;
cons_pool[current].cdrKind = NIL;
cons_pool[current].car =
cons_pool[cons_pool[cons_pool[cons_pool[func_expr].cdr].cdr].cdr].car;
#ifdef DEFUN_SECURE_BODY
memptr local_security = safe_allocate_cons();
cons_pool[local_security].car = cons_pool[current].car;
cons_pool[local_security].carKind = CONS;
cons_pool[local_security].cdrKind = NIL;
#endif
// hashing the function into the system
memptr env = lookup(function, ENVIRONMENT);
if (env == NOT_FOUND) {
// inserting to current environment
insert_symbol(environment, function);
} else {
// replacing previous interpretation
remove_symbol(env, function);
insert_symbol(env, function);
}
return cons_pool[function].cdr;
}
memptr func_setq(memptr func_expr) {
if (num_nodes(func_expr) != 3) {
// invalid call
#ifdef DEBUG
printf("22\n");
#endif
ERROR(ERROR_SETQ, ERROR_FAILURE, ERROR_INVALID, ERROR_COUNT);
return NOT_FOUND;
}
memptr local_security = safe_allocate_cons();
cons_pool[local_security].carKind = NIL;
cons_pool[local_security].cdrKind = NIL;
memptr current_node = cons_pool[func_expr].cdr;
memptr current_param = cons_pool[current_node].car;
Type first_type = type(current_param);
if (first_type != TYPE_SYMBOL) {
// first argument not a name
#ifdef DEBUG
printf("23\n");
#endif
ERROR(ERROR_SETQ, ERROR_FAILURE, ERROR_INVALID, ERROR_MALFORMED);
return NOT_FOUND;
}
memptr symbol_name = current_param;
current_node = cons_pool[current_node].cdr;
current_param = cons_pool[current_node].car;
memptr value = resolve_expr(current_param);
if (value == NOT_FOUND) {
// invalid value
#ifdef DEBUG
printf("24\n");
#endif
ERROR(ERROR_SETQ, ERROR_FAILURE, ERROR_INVALID, ERROR_EMPTY);
return NOT_FOUND;
}
cons_pool[local_security].car = value;
cons_pool[local_security].carKind = CONS;
// defining the new symbol
memptr symbol = allocate_cons();
cons_pool[local_security].cdr = symbol;
cons_pool[local_security].cdrKind = CONS;
cons_pool[symbol].car = cons_pool[symbol_name].car;
cons_pool[symbol].carKind = STRING;
cons_pool[symbol].cdr = value;
cons_pool[symbol].cdrKind = CONS;
memptr env = lookup(symbol, ENVIRONMENT);
if (env == NOT_FOUND) {
// inserting to current environment
insert_symbol(environment, symbol); // includes 1 allocation
} else {
// replacing previous interpretation
remove_symbol(env, symbol);
insert_symbol(env, symbol); // includes 1 allocation
}
return value;
}
