tree_t type_field(type_t t, unsigned n)
{
if (t->kind == T_SUBTYPE)
return type_field(type_base(t), n);
else
return tree_array_nth(&(lookup_item(t, I_FIELDS)->tree_array), n);
}
unsigned type_fields(type_t t)
{
if (t->kind == T_SUBTYPE)
return type_fields(type_base(t));
else
return lookup_item(t, I_FIELDS)->tree_array.count;
}
void
pktgen_set_theme_item( char * item, char * fg_color, char * bg_color, char * attr)
{
theme_color_map_t * elem;
color_e fg, bg;
attr_e at;
elem = lookup_item(item);
if ( elem == NULL ) {
pktgen_log_error("Unknown item name (%s)\n", item);
return;
}
fg = get_color_by_name(fg_color);
bg = get_color_by_name(bg_color);
at = get_attr_by_name(attr);
if ( (fg == UNKNOWN_COLOR) || (bg == UNKNOWN_COLOR) || (at == UNKNOWN_ATTR) ) {
pktgen_log_error("Unknown color or attribute (%s, %s, %s)\n", fg_color, bg_color, attr);
return;
}
elem->fg_color = fg;
elem->bg_color = bg;
elem->attr = at;
}
_export void module_cleanup() {
struct iterator it = list_iterator(&items);
item_t *i;
while ((i = iterator_next(&it))) {
if (!is_blocked(i)) {
logitem("failed to pick ");
if (i->amount > 1) logitem("%i ", i->amount);
if (i->ethereal) logitem("ethereal ");
if (i->quality != 0x00) logitem("%s ", qualities[i->quality]);
logitem("%s", lookup_item(i));
if (i->quality != 0x00) logitem(" (%i)", i->level);
if (i->sockets > 0) logitem(" [%i]", i->sockets);
if (setting("Debug")->b_var) logitem(" distance: %i", i->distance); // test pickit
logitem("\n");
}
}
list_clear(&items);
gold = 0;
routine_scheduled = FALSE;
}
type_t type_elem(type_t t)
{
assert(t != NULL);
if (IS(t, T_SUBTYPE))
return type_elem(type_base(t));
else {
item_t *item = lookup_item(t, I_ELEM);
assert(item->type != NULL);
return item->type;
}
}
/* Changes the color to the color of the specified element */
void
pktgen_display_set_color(const char *elem) {
theme_color_map_t *theme_color;
if ( scrn->theme == THEME_OFF )
return;
theme_color = lookup_item(elem);
if (theme_color == NULL) {
pktgen_log_error("Unknown color '%s'", elem);
return;
}
scrn_color(theme_color->fg_color, theme_color->bg_color, theme_color->attr);
}
/* String to use as prompt, with proper ANSI color codes */
const char *
pktgen_get_prompt(void)
{
theme_color_map_t *def, *prompt;
// Set default return value.
snprintf(prompt_str, sizeof(prompt_str), "%s> ", PKTGEN_APP_NAME);
if ( scrn->theme == THEME_ON ) {
// Look up the default and prompt values
def = lookup_item(NULL);
prompt = lookup_item("pktgen.prompt");
if ( (def == NULL) || (prompt == NULL) )
pktgen_log_error("Prompt and/or default color undefined");
else
snprintf(prompt_str, sizeof(prompt_str), "\033[%d;%d;%dm%s>\033[%d;%d;%dm ",
prompt->attr, 30 + prompt->fg_color, 40 + prompt->bg_color,
PKTGEN_APP_NAME,
def->attr, 30 + def->fg_color, 40 + def->bg_color);
}
return prompt_str;
}
file_types_default_t::file_types_default_t(string_t const &, config_t const &config) :
file_types_t() {
if(config::check)
return;
string_t string = string_file(config.mime_types_filename.str());
in_t::ptr_t p = string;
parse_item(string_t::empty, p, 0);
if(!size)
return;
for(
config::list_t<string_t>::ptr_t ptr = config.allow_gzip_list;
ptr; ++ptr
) {
item_t *item = lookup_item(ptr.val());
if(item) item->allow_gzip = true;
}
}
type_t type_index_constr(type_t t, unsigned n)
{
return type_array_nth(&(lookup_item(t, I_INDEX_CONSTR)->type_array), n);
}
void type_change_index_constr(type_t t, unsigned n, type_t c)
{
type_array_t *a = &(lookup_item(t, I_INDEX_CONSTR)->type_array);
assert(n < a->count);
a->items[n] = c;
}
void type_add_index_constr(type_t t, type_t c)
{
type_array_add(&(lookup_item(t, I_INDEX_CONSTR)->type_array), c);
}
unsigned type_enum_literals(type_t t)
{
return lookup_item(t, I_LITERALS)->tree_array.count;
}
void type_set_file(type_t t, type_t f)
{
lookup_item(t, I_FILE)->type = f;
}
void type_set_access(type_t t, type_t a)
{
lookup_item(t, I_ACCESS)->type = a;
}
tree_t type_resolution(type_t t)
{
item_t *item = lookup_item(t, I_RESOLUTION);
assert(item->tree != NULL);
return item->tree;
}
tree_t type_unit(type_t t, unsigned n)
{
return tree_array_nth(&(lookup_item(t, I_UNITS)->tree_array), n);
}
void type_add_param(type_t t, type_t p)
{
type_array_add(&(lookup_item(t, I_PARAMS)->type_array), p);
}
type_t type_param(type_t t, unsigned n)
{
return type_array_nth(&(lookup_item(t, I_PARAMS)->type_array), n);
}
unsigned type_params(type_t t)
{
return lookup_item(t, I_PARAMS)->type_array.count;
}
void type_enum_add_literal(type_t t, tree_t lit)
{
assert(tree_kind(lit) == T_ENUM_LIT);
tree_array_add(&(lookup_item(t, I_LITERALS)->tree_array), lit);
}
tree_t type_enum_literal(type_t t, unsigned n)
{
return tree_array_nth(&(lookup_item(t, I_LITERALS)->tree_array), n);
}
void type_set_resolution(type_t t, tree_t r)
{
lookup_item(t, I_RESOLUTION)->tree = r;
}
bool type_has_resolution(type_t t)
{
return lookup_item(t, I_RESOLUTION)->tree != NULL;
}
type_t type_result(type_t t)
{
item_t *item = lookup_item(t, I_RESULT);
assert(item->type != NULL);
return item->type;
}
type_t type_access(type_t t)
{
return lookup_item(t, I_ACCESS)->type;
}
void type_set_result(type_t t, type_t r)
{
lookup_item(t, I_RESULT)->type = r;
}
type_t type_file(type_t t)
{
return lookup_item(t, I_FILE)->type;
}
unsigned type_index_constrs(type_t t)
{
return lookup_item(t, I_INDEX_CONSTR)->type_array.count;
}
void type_add_field(type_t t, tree_t p)
{
assert(tree_kind(p) == T_FIELD_DECL);
tree_array_add(&(lookup_item(t, I_FIELDS)->tree_array), p);
}
void type_add_unit(type_t t, tree_t u)
{
tree_array_add(&(lookup_item(t, I_UNITS)->tree_array), u);
}
