void dump_names (AST * entry)
{
AST * field;
char * fname;
char * value;
int i;
bt_stringlist *
namelist;
bt_name * name;
if (bt_entry_metatype (entry) != BTE_REGULAR)
{
printf ("skipping %s entry\n", bt_entry_type (entry));
return;
}
else
{
printf ("%s: %s\n", bt_entry_key (entry), bt_entry_type (entry));
}
field = NULL;
while ((field = bt_next_field (entry, field, &fname)))
{
if (strcmp (fname, "author") == 0 ||
strcmp (fname, "editor") == 0)
{
value = bt_get_text (field);
printf ("field: %s:\n", fname);
printf (" %s\n", value);
namelist = bt_split_list (value, "and", NULL, 0, "name");
if (namelist != NULL)
{
printf (" splits into %d names:\n", namelist->num_items);
for (i = 0; i < namelist->num_items; i++)
{
printf (" %s\n", namelist->items[i]);
name = bt_split_name (namelist->items[i], NULL, 0, i);
printf (" ");
dump_component ("first", name, BTN_FIRST, "; ");
dump_component ("von", name, BTN_VON, "; ");
dump_component ("last", name, BTN_LAST, "; ");
dump_component ("jr", name, BTN_JR, NULL);
printf ("\n");
}
}
}
}
} /* dump_names () */
void dump_top_level_form(struct component *c)
{
if (!ModuleDumped) {
dump_op(fop_IN_MODULE);
dump_symbol(ModuleName);
ModuleDumped = true;
}
dump_op(fop_TOP_LEVEL_FORM);
dump_component(c);
}
void dump_defvar(struct param_list *params, struct component *initializer)
{
if (!ModuleDumped) {
dump_op(fop_IN_MODULE);
dump_symbol(ModuleName);
ModuleDumped = true;
}
dump_op(fop_DEFINE_VARIABLE);
dump_defconst_or_var(params);
dump_component(initializer);
}
void dump_defgeneric(struct id *name, struct component *tlf)
{
if (!ModuleDumped) {
dump_op(fop_IN_MODULE);
dump_symbol(ModuleName);
ModuleDumped = true;
}
dump_op(fop_DEFINE_GENERIC);
dump_symbol(name->symbol);
dump_component(tlf);
}
void dump_defmethod(struct id *name, struct component *c)
{
if (!ModuleDumped) {
dump_op(fop_IN_MODULE);
dump_symbol(ModuleName);
ModuleDumped = true;
}
dump_op(fop_DEFINE_METHOD);
dump_symbol(name->symbol);
dump_component(c);
}
void dump_defclass(struct id *name, struct slot_spec *slots,
struct component *tlf1, struct component *tlf2)
{
struct slot_spec *slot;
if (!ModuleDumped) {
dump_op(fop_IN_MODULE);
dump_symbol(ModuleName);
ModuleDumped = true;
}
dump_op(fop_DEFINE_CLASS);
dump_symbol(name->symbol);
for (slot = slots; slot != NULL; slot = slot->next) {
dump_symbol(slot->getter->symbol);
if (slot->setter)
dump_symbol(slot->setter->symbol);
}
dump_op(fop_FALSE);
dump_component(tlf1);
dump_component(tlf2);
}
static void dump_method(struct method *method)
{
struct param_list *params = method->params;
struct keyword_param *k;
int param_info, nkeys;
int nclosure_vars;
struct closes_over *over;
if (params->rest_param)
param_info = 1;
else
param_info = 0;
if (params->all_keys)
param_info |= 2;
if (params->allow_keys) {
nkeys = 0;
for (k = params->keyword_params; k != NULL; k = k->next)
nkeys++;
param_info = param_info | (nkeys+1)<<2;
}
nclosure_vars = 0;
for (over = method->closes_over; over != NULL; over = over->next)
nclosure_vars++;
if (param_info < 256 && nclosure_vars < 256) {
dump_op(fop_SHORT_METHOD);
dump_byte(param_info);
dump_byte(nclosure_vars);
}
else {
dump_op(fop_METHOD);
dump_int(param_info);
dump_int(nclosure_vars);
}
for (k = params->keyword_params; k != NULL; k = k->next) {
struct literal_expr *def = (struct literal_expr *)k->def;
dump_symbol(k->keyword);
if (def) {
if (def->kind != expr_LITERAL)
lose("non-literal keyword default made it though expand?");
dump_literal(def->lit);
}
else
dump_op(fop_FALSE);
}
dump_component(method->component);
}
void dump_all_mmal_component(RASPIVID_STATE *state)
{
dump_component( (char *)"Camera : ", state->camera_component );
dump_component( (char *)"Encoder: ", state->encoder_component );
// dump_component( "Preview: ", state->preview_parameters->preview_component );
}
