static gboolean
execute_find (MuStore *store, MuConfig *opts, GError **err)
{
char *query_str;
MuQuery *oracle;
gboolean rv;
oracle = get_query_obj (store, err);
if (!oracle)
return FALSE;
query_str = get_query (opts, err);
if (!query_str) {
mu_query_destroy (oracle);
return FALSE;
}
if (opts->format == MU_CONFIG_FORMAT_XQUERY)
rv = print_internal (oracle, query_str, TRUE, FALSE, err);
else if (opts->format == MU_CONFIG_FORMAT_MQUERY)
rv = print_internal (oracle, query_str, FALSE,
opts->verbose, err);
else
rv = process_query (oracle, query_str, opts, err);
mu_query_destroy (oracle);
g_free (query_str);
return rv;
}
void print_block(struct buffer_head *bh, ...) //int print_mode, int first, int last)
{
va_list args;
int mode, first, last;
if (!bh) {
printk("print_block: buffer is NULL\n");
return;
}
va_start(args, bh);
mode = va_arg(args, int);
first = va_arg(args, int);
last = va_arg(args, int);
if (print_leaf(bh, mode, first, last))
if (print_internal(bh, first, last))
if (print_super_block(bh))
if (print_desc_block(bh))
printk
("Block %llu contains unformatted data\n",
(unsigned long long)bh->b_blocknr);
va_end(args);
}
static void
ase_metric_prnt(Lisp_Object obj, Lisp_Object pcf, int unused)
{
EMOD_ASE_DEBUG_METR("m:0x%08x@0x%08x (rc:%d)\n",
(unsigned int)(XASE_METRIC(obj)),
(unsigned int)obj, 1);
write_c_string("#<", pcf);
print_internal(XDYNACAT_TYPE(obj), pcf, unused);
{
if (NILP(XASE_METRIC_LDIST(obj))) {
write_hex_ptr(XASE_METRIC_DIST(obj),pcf);
} else {
Lisp_Object ldist = XASE_METRIC_LDIST(obj);
if (SYMBOLP(ldist)) {
Lisp_String *name =
symbol_name(XSYMBOL(ldist));
write_fmt_string(pcf, " #'%s", string_data(name));
} else if (SUBRP(ldist)) {
const char *name = subr_name(XSUBR(ldist));
write_fmt_string(pcf, " #'%s", name);
} else {
write_c_string(" #'(lambda ...)", pcf);
}
}
}
write_c_string(">", pcf);
return;
}
static void
sound_oss_print(Lisp_Object device, Lisp_Object pcfun, int ef)
{
sound_oss_data_t *sod = NULL;
sod = get_audio_device_data(device);
/* cannot use incomplete or corrupt audio devices */
if (XAUDIO_DEVICE_DRIVER(device) != MYSELF || sod == NULL) {
write_c_string(" VOID", pcfun);
/* now that we are here, mark AO device as dead */
XAUDIO_DEVICE_STATE(device) = ASTATE_DEAD;
return;
}
/* info about the connected output plugin */
write_c_string(" :device ", pcfun);
if (NILP(sod->device))
write_c_string("\"/dev/dsp\"", pcfun);
else
print_internal(sod->device, pcfun, ef);
if (sod->lock) {
write_c_string(" :busy t", pcfun);
} else
write_c_string(" :busy nil", pcfun);
if (sod->keep_open) {
write_c_string(" :keep-open t", pcfun);
} else
write_c_string(" :keep-open nil", pcfun);
return;
}
static void
ase_cartesian_prnt(Lisp_Object obj, Lisp_Object pcf, int unused)
{
EMOD_ASE_DEBUG_CART("n:0x%08x@0x%08x (rc:%d)\n",
(unsigned int)(XASE_CARTESIAN(obj)),
(unsigned int)obj, 1);
write_c_string("#<", pcf);
print_internal(XDYNACAT_TYPE(obj), pcf, unused);
if (!NILP(XASE_CARTESIAN_INTERIOR_TYPE(obj))) {
print_internal(XASE_CARTESIAN_INTERIOR_TYPE(obj), pcf, unused);
}
write_fmt_str(pcf, " of dimension %d, ",
XASE_CARTESIAN_DIMENSION(obj));
_ase_cartesian_prnt(XASE_CARTESIAN(obj), pcf);
write_c_string(">", pcf);
}
void printWarning(const char* const tag, const char* const fmt, ... )
{
va_list ap;
va_start(ap, fmt);
#if defined(_WIN32)
print_internal(COLOR_WARNING, "Warning", tag, fmt, ap );
#endif
#if defined(ANDROID)
__android_log_vprint(ANDROID_LOG_INFO, tag, fmt, ap);
#endif
va_end(ap);
}
void printLog(const char* const tag, const char* const fmt, ... )
{
va_list ap;
va_start(ap, fmt);
#if defined(_WIN32)
print_internal(COLOR_LOG, "Log", tag, fmt, ap );
#endif
#if defined(ANDROID)
__android_log_vprint(ANDROID_LOG_DEBUG, tag, fmt, ap);
#endif
va_end(ap);
}
void printError(const char* const tag, const char* const fmt, ... )
{
va_list ap;
va_start(ap, fmt);
#if defined(_WIN32)
print_internal(COLOR_ERROR, "Error", tag, fmt, ap );
#endif
#if defined(ANDROID)
__android_log_vprint(ANDROID_LOG_ERROR, tag, fmt, ap);
#endif
va_end(ap);
}
static void
_ase_cartesian_prnt(ase_cartesian_t n, Lisp_Object pcf)
{
Lisp_Object *objs;
int i;
objs = n->objects;
for (i = 0; i < n->dimension; i++) {
Lisp_Object obji = objs[i];
if (!_ase_cartesian_prnt_ase_object(obji, pcf)) {
print_internal(objs[i], pcf, 0);
}
if (i+1 < n->dimension)
write_c_string(" x ", pcf);
}
}
static int print_node(state_t *state, bithenge_node_t *tree)
{
switch (bithenge_node_type(tree)) {
case BITHENGE_NODE_INTERNAL:
return print_internal(state, tree);
case BITHENGE_NODE_BOOLEAN:
return print_boolean(state, tree);
case BITHENGE_NODE_INTEGER:
return print_integer(state, tree);
case BITHENGE_NODE_STRING:
return print_string(state, tree);
case BITHENGE_NODE_BLOB:
return print_blob(state, tree);
}
return ENOTSUP;
}
static void
print_ldap(Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
{
char buf[32];
Lisp_LDAP *ldap = XLDAP(obj);
if (print_readably)
error("printing unreadable object #<ldap %s>",
XSTRING_DATA(ldap->host));
write_c_string("#<ldap ", printcharfun);
print_internal(ldap->host, printcharfun, 1);
if (!ldap->ld)
write_c_string("(dead) ", printcharfun);
write_fmt_string(printcharfun, " 0x%lx>", (long)ldap);
}
void
tipc_print(netdissect_options *ndo, const u_char *bp, u_int length _U_,
u_int caplen _U_)
{
const struct tipc_pkthdr *ap;
u_int32_t w0;
u_int user;
ap = (struct tipc_pkthdr *)bp;
ND_TCHECK(ap->w0);
w0 = EXTRACT_32BITS(&ap->w0);
user = TIPC_USER(w0);
switch (user)
{
case TIPC_USER_LOW_IMPORTANCE:
case TIPC_USER_MEDIUM_IMPORTANCE:
case TIPC_USER_HIGH_IMPORTANCE:
case TIPC_USER_CRITICAL_IMPORTANCE:
case TIPC_USER_NAME_DISTRIBUTOR:
case TIPC_USER_CONN_MANAGER:
print_payload(ndo, (struct payload_tipc_pkthdr *)bp);
break;
case TIPC_USER_LINK_CONFIG:
print_link_conf(ndo, (struct link_conf_tipc_pkthdr *)bp);
break;
case TIPC_USER_BCAST_PROTOCOL:
case TIPC_USER_MSG_BUNDLER:
case TIPC_USER_LINK_PROTOCOL:
case TIPC_USER_CHANGEOVER_PROTOCOL:
case TIPC_USER_MSG_FRAGMENTER:
print_internal(ndo, (struct internal_tipc_pkthdr *)bp);
break;
}
return;
trunc:
ND_PRINT((ndo, "[|TIPC]"));
}
static void
print_database (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
{
char buf[64];
Lisp_Database *db = XDATABASE (obj);
if (print_readably)
error ("printing unreadable object #<database 0x%x>", db->header.uid);
write_c_string ("#<database \"", printcharfun);
print_internal (db->fname, printcharfun, 0);
sprintf (buf, "\" (%s/%s/%s) 0x%x>",
(char *) string_data (XSYMBOL (db->funcs->get_type (db))->name),
(char *) string_data (XSYMBOL (db->funcs->get_subtype (db))->name),
(!DATABASE_LIVE_P (db) ? "closed" :
(db->access_ & O_WRONLY) ? "writeonly" :
(db->access_ & O_RDWR) ? "readwrite" : "readonly"),
db->header.uid);
write_c_string (buf, printcharfun);
}
static void
print_device (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
{
struct device *d = XDEVICE (obj);
char buf[256];
if (print_readably)
error ("printing unreadable object #<device %s 0x%x>",
XSTRING_DATA (d->name), d->header.uid);
sprintf (buf, "#<%s-device", !DEVICE_LIVE_P (d) ? "dead" :
DEVICE_TYPE_NAME (d));
write_c_string (buf, printcharfun);
if (DEVICE_LIVE_P (d) && !NILP (DEVICE_CONNECTION (d)))
{
write_c_string (" on ", printcharfun);
print_internal (DEVICE_CONNECTION (d), printcharfun, 1);
}
sprintf (buf, " 0x%x>", d->header.uid);
write_c_string (buf, printcharfun);
}
int main(int argc, char *argv[])
{
jackctl_server_t * server;
const JSList * parameters;
const JSList * drivers;
const JSList * internals;
const JSList * node_ptr;
jackctl_sigmask_t * sigmask;
int opt, option_index;
const char* driver_name = "dummy";
const char* client_name = "audioadapter";
const char *options = "d:c:";
struct option long_options[] = {
{"driver", 1, 0, 'd'},
{"client", 1, 0, 'c'},
};
while ((opt = getopt_long (argc, argv, options, long_options, &option_index)) != EOF) {
switch (opt) {
case 'd':
driver_name = optarg;
break;
case 'c':
client_name = optarg;
break;
default:
usage();
exit(0);
}
}
server = jackctl_server_create(NULL, NULL);
parameters = jackctl_server_get_parameters(server);
/*
jackctl_parameter_t* param;
union jackctl_parameter_value value;
param = jackctl_get_parameter(parameters, "verbose");
if (param != NULL) {
value.b = true;
jackctl_parameter_set_value(param, &value);
}
*/
printf("\n========================== \n");
printf("List of server parameters \n");
printf("========================== \n");
print_parameters(parameters);
printf("\n========================== \n");
printf("List of drivers \n");
printf("========================== \n");
drivers = jackctl_server_get_drivers_list(server);
node_ptr = drivers;
while (node_ptr != NULL) {
print_driver((jackctl_driver_t *)node_ptr->data);
node_ptr = jack_slist_next(node_ptr);
}
printf("\n========================== \n");
printf("List of internal clients \n");
printf("========================== \n");
internals = jackctl_server_get_internals_list(server);
node_ptr = internals;
while (node_ptr != NULL) {
print_internal((jackctl_internal_t *)node_ptr->data);
node_ptr = jack_slist_next(node_ptr);
}
// No error checking in this simple example...
jackctl_server_open(server, jackctl_server_get_driver(server, driver_name));
jackctl_server_start(server);
jackctl_server_load_internal(server, jackctl_server_get_internal(server, client_name));
/*
// Switch master test
jackctl_driver_t* master;
usleep(5000000);
printf("jackctl_server_load_master\n");
master = jackctl_server_get_driver(server, "coreaudio");
jackctl_server_switch_master(server, master);
usleep(5000000);
printf("jackctl_server_load_master\n");
master = jackctl_server_get_driver(server, "dummy");
jackctl_server_switch_master(server, master);
*/
sigmask = jackctl_setup_signals(0);
jackctl_wait_signals(sigmask);
jackctl_server_stop(server);
jackctl_server_close(server);
jackctl_server_destroy(server);
return 0;
}
