void
test_select(void)
{
grn_obj *v;
prepare_data();
cut_assert_not_null((cond = grn_expr_create(&context, NULL, 0)));
v = grn_expr_add_var(&context, cond, NULL, 0);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs));
grn_expr_append_obj(&context, cond, v, GRN_OP_PUSH, 1);
GRN_TEXT_SETS(&context, &textbuf, "size");
grn_expr_append_const(&context, cond, &textbuf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, cond, GRN_OP_GET_VALUE, 2);
GRN_UINT32_SET(&context, &intbuf, 14);
grn_expr_append_const(&context, cond, &intbuf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, cond, GRN_OP_EQUAL, 2);
grn_expr_compile(&context, cond);
res = grn_table_create(&context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, docs, NULL);
cut_assert_not_null(res);
cut_assert_not_null((expr = grn_expr_create(&context, NULL, 0)));
grn_expr_append_obj(&context, expr, docs, GRN_OP_PUSH, 1);
grn_expr_append_obj(&context, expr, cond, GRN_OP_PUSH, 1);
grn_expr_append_obj(&context, expr, res, GRN_OP_PUSH, 1);
GRN_UINT32_SET(&context, &intbuf, GRN_OP_OR);
grn_expr_append_const(&context, expr, &intbuf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, expr, GRN_OP_TABLE_SELECT, 4);
grn_expr_exec(&context, expr, 0);
grn_test_assert_select(&context,
gcut_take_new_list_string("moge moge moge",
"hoge fuga fuga",
"moge hoge hoge",
NULL),
res,
"body");
}
int __near_agent_handover_push_data(enum ho_agent_carrier carrier,
struct carrier_data *data)
{
DBusMessage *message;
DBusMessage *reply;
DBusError error;
struct near_handover_agent *agent = NULL;
agent = g_hash_table_lookup(ho_agent_hash, GINT_TO_POINTER(carrier));
if (!agent)
return -ESRCH;
message = dbus_message_new_method_call(agent->sender,
agent->path, NFC_HANDOVER_AGENT_INTERFACE,
"PushOOB");
if (!message)
return -ENOMEM;
prepare_data(message, data);
dbus_error_init(&error);
reply = dbus_connection_send_with_reply_and_block(connection, message,
DBUS_TIMEOUT_USE_DEFAULT, &error);
dbus_message_unref(message);
if (reply) {
dbus_message_unref(reply);
return 0;
}
if (dbus_error_is_set(&error)) {
near_error("PushOOB failed: %s", error.message);
dbus_error_free(&error);
} else {
near_error("PushOOB failed");
}
return -EIO;
}
void main() {
char c = ' ';
while (c != 'q') {
clear_screen();
cout << "Press:" << endl;
cout << "'d' to prepare computation Data" << endl;
cout << "'m' to prepare Model" << endl;
cout << "'s' to prepare Sources" << endl;
cout << "'r' to prepare Receivers" << endl;
cout << "'q' to Quit" << endl;
cin >> c;
if (c == 'd') prepare_data();
if (c == 'm') prepare_model();
if (c == 's') prepare_source();
if (c == 'r') prepare_receivers();
}
}
void
test_allow_update(gconstpointer data)
{
grn_obj *v;
prepare_data();
expr = grn_expr_create(&context, NULL, 0);
cut_assert_not_null(expr);
v = grn_expr_add_var(&context, expr, NULL, 0);
cut_assert_not_null(v);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs));
PARSE(expr,
gcut_data_get_string(data, "query"),
GRN_EXPR_SYNTAX_QUERY | GRN_EXPR_ALLOW_COLUMN | GRN_EXPR_ALLOW_UPDATE);
res = grn_table_select(&context, docs, expr, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select(&context,
gcut_data_get_pointer(data, "expected_keys"),
res,
"body");
}
void
test_equal_by_existent_reference_key(void)
{
grn_obj *v;
prepare_data();
GRN_EXPR_CREATE_FOR_QUERY(&context, docs, cond, v);
cut_assert_not_null(cond);
cut_assert_not_null(v);
PARSE(cond, "author == \"morita\"", GRN_EXPR_SYNTAX_SCRIPT);
res = grn_table_select(&context, docs, cond, NULL, GRN_OP_OR);
cut_assert_not_null(res);
grn_test_assert_select(&context,
gcut_take_new_list_string(
"fuga fuga",
"hoge",
"poyo moge hoge moge moge moge",
NULL),
res,
"body");
}
void
test_match(void)
{
grn_obj *v;
prepare_data();
cut_assert_not_null((cond = grn_expr_create(&context, NULL, 0)));
v = grn_expr_add_var(&context, cond, NULL, 0);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs));
grn_expr_append_obj(&context, cond, v, GRN_OP_PUSH, 1);
GRN_TEXT_SETS(&context, &text_buf, "body");
grn_expr_append_const(&context, cond, &text_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, cond, GRN_OP_GET_VALUE, 2);
GRN_TEXT_SETS(&context, &text_buf, "moge");
grn_expr_append_const(&context, cond, &text_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, cond, GRN_OP_MATCH, 2);
grn_expr_compile(&context, cond);
res = grn_table_create(&context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, docs, NULL);
cut_assert_not_null(res);
cut_assert_not_null(grn_table_select(&context, docs, cond, res, GRN_OP_OR));
grn_test_assert_select(&context,
gcut_take_new_list_string("moge moge moge",
"hoge moge moge moge",
"moge hoge hoge",
"moge hoge fuga fuga",
"moge hoge moge moge moge",
"poyo moge hoge "
"moge moge moge",
NULL),
res,
"body");
}
void dlm_timeout_warn(struct dlm_lkb *lkb)
{
struct sk_buff *uninitialized_var(send_skb);
struct dlm_lock_data *data;
size_t size;
int rv;
size = nla_total_size(sizeof(struct dlm_lock_data)) +
nla_total_size(0); /* why this? */
rv = prepare_data(DLM_CMD_TIMEOUT, &send_skb, size);
if (rv < 0)
return;
data = mk_data(send_skb);
if (!data) {
nlmsg_free(send_skb);
return;
}
fill_data(data, lkb);
send_data(send_skb);
}
static PyObject *Revision_set_object_data(
Revision *self, PyObject *args, PyObject *kwds)
{
PyObject *ob_arg = NULL, *data_arg = NULL;
static char *kwlist[] = { "ob", "data", NULL };
if (!PyArg_ParseTupleAndKeywords(
args, kwds, "O!O:Revision.set_object_data", kwlist,
&ObjectType, &ob_arg, &data_arg))
return NULL;
if (!xorn_revision_is_transient(self->rev))
return not_transient();
xorn_obtype_t type = xorn_obtype_none;
const void *data = NULL;
if (prepare_data(data_arg, &type, &data) == -1) {
char buf[BUFSIZ];
snprintf(buf, BUFSIZ,
"Revision.set_object_data() argument 'data' (pos 2) "
"must be of xorn.storage object type, not %.50s",
data_arg->ob_type->tp_name);
PyErr_SetString(PyExc_TypeError, buf);
return NULL;
}
if (type != xornsch_obtype_text) {
xorn_object_t attached_to;
if (xorn_get_object_location(self->rev, ((Object *)ob_arg)->ob,
&attached_to, NULL) != -1 &&
attached_to != NULL) {
PyErr_SetString(PyExc_ValueError,
"Cannot set attached object to "
"something other than text");
return NULL;
}
}
if (type != xornsch_obtype_net && type != xornsch_obtype_component) {
size_t count;
if (xorn_get_objects_attached_to(
self->rev, ((Object *)ob_arg)->ob,
NULL, &count) != -1 && count != 0) {
PyErr_SetString(
PyExc_ValueError,
"Cannot set object with attached objects to "
"something other than net or component");
return NULL;
}
}
if (xorn_set_object_data(self->rev, ((Object *)ob_arg)->ob,
type, data) == -1)
return PyErr_NoMemory();
Py_INCREF(Py_None);
return Py_None;
}
void
test_scan_search(void)
{
grn_obj *cond, *expr, *v, textbuf, intbuf;
GRN_TEXT_INIT(&textbuf, 0);
GRN_UINT32_INIT(&intbuf, 0);
prepare_data(&textbuf, &intbuf);
cut_assert_not_null((cond = grn_expr_create(&context, NULL, 0)));
v = grn_expr_add_var(&context, cond, NULL, 0);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs));
grn_expr_append_obj(&context, cond, v);
GRN_TEXT_SETS(&context, &textbuf, "size");
grn_expr_append_const(&context, cond, &textbuf);
grn_expr_append_op(&context, cond, GRN_OP_OBJ_GET_VALUE, 2);
GRN_UINT32_SET(&context, &intbuf, 14);
grn_expr_append_const(&context, cond, &intbuf);
grn_expr_append_op(&context, cond, GRN_OP_EQUAL, 2);
grn_expr_compile(&context, cond);
cut_assert_not_null((expr = grn_expr_create(&context, NULL, 0)));
v = grn_expr_add_var(&context, expr, NULL, 0);
GRN_BULK_REWIND(&textbuf);
grn_expr_append_const(&context, expr, &textbuf);
GRN_UINT32_SET(&context, &intbuf, GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC);
grn_expr_append_const(&context, expr, &intbuf);
grn_expr_append_obj(&context, expr, docs);
GRN_UINT32_SET(&context, &intbuf, 0);
grn_expr_append_const(&context, expr, &intbuf);
grn_expr_append_op(&context, expr, GRN_OP_TABLE_CREATE, 4);
grn_expr_append_obj(&context, expr, v);
grn_expr_append_op(&context, expr, GRN_OP_VAR_SET_VALUE, 2);
grn_expr_append_obj(&context, expr, docs);
grn_expr_append_obj(&context, expr, cond);
grn_expr_append_obj(&context, expr, v);
GRN_UINT32_SET(&context, &intbuf, GRN_SEL_OR);
grn_expr_append_const(&context, expr, &intbuf);
grn_expr_append_op(&context, expr, GRN_OP_TABLE_SCAN, 4);
grn_expr_append_obj(&context, expr, index_body);
GRN_TEXT_SETS(&context, &textbuf, "moge");
grn_expr_append_const(&context, expr, &textbuf);
grn_expr_append_obj(&context, expr, v);
GRN_UINT32_SET(&context, &intbuf, GRN_SEL_AND);
grn_expr_append_const(&context, expr, &intbuf);
grn_expr_append_op(&context, expr, GRN_OP_OBJ_SEARCH, 4);
grn_expr_append_obj(&context, expr, v);
GRN_TEXT_SETS(&context, &textbuf, ".size .:score .body");
grn_expr_append_const(&context, expr, &textbuf);
GRN_BULK_REWIND(&textbuf);
grn_expr_append_obj(&context, expr, &textbuf);
grn_expr_append_op(&context, expr, GRN_OP_JSON_PUT, 3);
grn_expr_exec(&context, expr);
cut_assert_equal_substring("[[14, 4, \"moge moge moge\"], [14, 2, \"moge hoge hoge\"]]",
GRN_TEXT_VALUE(&textbuf), GRN_TEXT_LEN(&textbuf));
grn_test_assert(grn_obj_close(&context, expr));
grn_test_assert(grn_obj_close(&context, cond));
grn_test_assert(grn_obj_close(&context, &textbuf));
grn_test_assert(grn_obj_close(&context, &intbuf));
}
void
test_parse(gconstpointer data)
{
grn_obj *v;
prepare_data();
cond = grn_expr_create(&context, NULL, 0);
cut_assert_not_null(cond);
v = grn_expr_add_var(&context, cond, NULL, 0);
cut_assert_not_null(v);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs));
PARSE(cond, gcut_data_get_string(data, "query_hoge_moge"),
gcut_data_get_int(data, "query_hoge_moge_parse_level"));
PARSE(cond, gcut_data_get_string(data, "query_poyo"),
gcut_data_get_int(data, "query_poyo_parse_level"));
grn_expr_append_op(&context, cond, GRN_OP_AND, 2);
grn_test_assert_expr(&context,
"noname($1:0){2body GET_VALUE,0\"hoge\",4MATCH,"
"2body GET_VALUE,0\"moge\",0MATCH,4AND,"
"2body GET_VALUE,0\"poyo\",0MATCH,0AND}",
cond);
res = grn_table_create(&context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, docs, NULL);
cut_assert_not_null(res);
cut_assert_not_null(grn_table_select(&context, docs, cond, res, GRN_OP_OR));
grn_test_assert_select(&context,
gcut_take_new_list_string("poyo moge hoge "
"moge moge moge",
NULL),
res,
"body");
grn_test_assert(grn_obj_close(&context, res));
res = NULL;
grn_test_assert(grn_obj_close(&context, cond));
cond = NULL;
cond = grn_expr_create(&context, NULL, 0);
cut_assert_not_null(cond);
v = grn_expr_add_var(&context, cond, NULL, 0);
cut_assert_not_null(v);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs));
PARSE(cond, gcut_data_get_string(data, "query_size"),
gcut_data_get_int(data, "query_size_parse_level"));
grn_test_assert_expr(&context,
"noname($1:0){2size GET_VALUE,014,0EQUAL}",
cond);
res = grn_table_create(&context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, docs, NULL);
cut_assert_not_null(res);
cut_assert_not_null(grn_table_select(&context, docs, cond, res, GRN_OP_OR));
grn_test_assert_select(&context,
gcut_take_new_list_string("moge moge moge",
"hoge fuga fuga",
"moge hoge hoge",
NULL),
res,
"body");
}
SerializerBase& BinarySerializer::operator%(SerializationData<BinarySerializer>&& var)
{
sprawl::String str = var.val.Str();
*this % prepare_data(str, var.name, var.PersistToDB);
return *this;
}
void Navi6dWrapper::update(const baro_data_t &baro,
const odometer_data_t &odo,
const marg_data_t &marg) {
osalDbgCheck(ready);
start_time_measurement();
/* restart sins if requested */
if (*restart != restart_cache) {
sins_cold_start();
restart_cache = *restart;
}
nav_sins.init_params.dT = marg.dT;
nav_sins.kalman_params.gnss_mean_pos_sigma = *R_pos_sns;
nav_sins.kalman_params.gnss_mean_alt_sigma = *R_alt_sns;
nav_sins.kalman_params.gnss_mean_vel_sigma = *R_vel_sns;
nav_sins.kalman_params.sigma_R.v_odo_x = *R_odo; //odo
nav_sins.kalman_params.sigma_R.v_nhl_y = *R_nhl_y; //nonhol
nav_sins.kalman_params.sigma_R.v_nhl_z = *R_nhl_z; //nonhol
nav_sins.kalman_params.sigma_R.alt_baro = *R_baro; //baro
nav_sins.kalman_params.sigma_R.mag_x = *R_mag; //mag
nav_sins.kalman_params.sigma_R.mag_y = *R_mag; //mag
nav_sins.kalman_params.sigma_R.mag_z = *R_mag; //mag
nav_sins.kalman_params.sigma_R.roll = *R_euler; //roll,pitch,yaw (rad)
nav_sins.kalman_params.sigma_R.pitch = *R_euler; //roll,pitch,yaw (rad)
nav_sins.kalman_params.sigma_R.yaw = *R_euler; //roll,pitch,yaw (rad)
nav_sins.kalman_params.sigma_R.v_nav_static = *R_v_nav_st; //roll,pitch,yaw (rad)
nav_sins.kalman_params.sigma_R.v_veh_static = *R_v_veh_st; //roll,pitch,yaw (rad)
nav_sins.kalman_params.sigma_R.yaw_static = *R_yaw_st; //roll,pitch,yaw (rad)
nav_sins.kalman_params.sigma_R.yaw_mag = *R_mag_yaw; //roll,pitch,yaw (rad)
nav_sins.kalman_params.sigma_Qm.acc_x = *Qm_acc; //acc
nav_sins.kalman_params.sigma_Qm.acc_y = *Qm_acc; //acc
nav_sins.kalman_params.sigma_Qm.acc_z = *Qm_acc; //accbias
nav_sins.kalman_params.sigma_Qm.gyr_x = *Qm_gyr; //gyr
nav_sins.kalman_params.sigma_Qm.gyr_y = *Qm_gyr; //gyr
nav_sins.kalman_params.sigma_Qm.gyr_z = *Qm_gyr; //gyr
nav_sins.kalman_params.sigma_Qm.acc_b_x = *Qm_acc_bias; //acc_x
nav_sins.kalman_params.sigma_Qm.acc_b_y = *Qm_acc_bias; //acc_y
nav_sins.kalman_params.sigma_Qm.acc_b_z = *Qm_acc_bias; //acc_z
nav_sins.kalman_params.sigma_Qm.gyr_b_x = *Qm_gyr_bias; //gyr_bias
nav_sins.kalman_params.sigma_Qm.gyr_b_y = *Qm_gyr_bias; //gyr_bias
nav_sins.kalman_params.sigma_Qm.gyr_b_z = *Qm_gyr_bias; //gyr_bias
nav_sins.kalman_params.Beta_inv.acc_b = *B_acc_b;
nav_sins.kalman_params.Beta_inv.gyr_b = *B_gyr_b;
nav_sins.kalman_params.Beta_inv.acc_s = 10000000.0;
nav_sins.kalman_params.Beta_inv.gyr_s = 10000000.0;
nav_sins.kalman_params.Beta_inv.acc_no = 10000000.0;
nav_sins.kalman_params.Beta_inv.gyr_no = 10000000.0;
nav_sins.calib_params.ba[0][0] = *acc_bias_x;
nav_sins.calib_params.ba[1][0] = *acc_bias_y;
nav_sins.calib_params.ba[2][0] = *acc_bias_z;
nav_sins.calib_params.bw[0][0] = *gyr_bias_x;
nav_sins.calib_params.bw[1][0] = *gyr_bias_y;
nav_sins.calib_params.bw[2][0] = *gyr_bias_z;
nav_sins.calib_params.sa[0][0] = *acc_scale_x;
nav_sins.calib_params.sa[1][0] = *acc_scale_y;
nav_sins.calib_params.sa[2][0] = *acc_scale_z;
nav_sins.calib_params.sw[0][0] = *gyr_scale_x;
nav_sins.calib_params.sw[1][0] = *gyr_scale_y;
nav_sins.calib_params.sw[2][0] = *gyr_scale_z;
nav_sins.ref_params.mag_dec = deg2rad(*mag_declinate);
nav_sins.calib_params.bm_marg[0][0] = *mag_bias_x;
nav_sins.calib_params.bm_marg[1][0] = *mag_bias_y;
nav_sins.calib_params.bm_marg[2][0] = *mag_bias_z;
nav_sins.calib_params.sm_marg[0][0] = *mag_scale_x;
nav_sins.calib_params.sm_marg[1][0] = *mag_scale_y;
nav_sins.calib_params.sm_marg[2][0] = *mag_scale_z;
nav_sins.calib_params.no_m_marg[0][0] = *mag_nort_x;
nav_sins.calib_params.no_m_marg[1][0] = *mag_nort_y;
nav_sins.calib_params.no_m_marg[2][0] = *mag_nort_z;
/*
nav_sins.calib_params.no_a[0][0] = *acc_nort_0;
nav_sins.calib_params.no_a[1][0] = *acc_nort_1;
nav_sins.calib_params.no_a[2][0] = *acc_nort_2;
nav_sins.calib_params.no_a[3][0] = *acc_nort_3;
nav_sins.calib_params.no_a[4][0] = *acc_nort_4;
nav_sins.calib_params.no_a[5][0] = *acc_nort_5;
nav_sins.calib_params.no_w[0][0] = *gyr_nort_0;
nav_sins.calib_params.no_w[1][0] = *gyr_nort_1;
nav_sins.calib_params.no_w[2][0] = *gyr_nort_2;
nav_sins.calib_params.no_w[3][0] = *gyr_nort_3;
nav_sins.calib_params.no_w[4][0] = *gyr_nort_4;
nav_sins.calib_params.no_w[5][0] = *gyr_nort_5;
*/
nav_sins.calib_params.ba[0][0] = *acc_bias_x;
nav_sins.calib_params.ba[1][0] = *acc_bias_y;
nav_sins.calib_params.ba[2][0] = *acc_bias_z;
nav_sins.calib_params.bw[0][0] = *gyr_bias_x;
nav_sins.calib_params.bw[1][0] = *gyr_bias_y;
nav_sins.calib_params.bw[2][0] = *gyr_bias_z;
nav_sins.calib_params.sa[0][0] = *acc_scale_x;
nav_sins.calib_params.sa[1][0] = *acc_scale_y;
nav_sins.calib_params.sa[2][0] = *acc_scale_z;
nav_sins.calib_params.sw[0][0] = *gyr_scale_x;
nav_sins.calib_params.sw[1][0] = *gyr_scale_y;
nav_sins.calib_params.sw[2][0] = *gyr_scale_z;
nav_sins.marg_b.eu_bs_mag[0][0] = M_PI;
nav_sins.marg_b.eu_bs_mag[1][0] = 0.0;
nav_sins.marg_b.eu_bs_mag[2][0] = -M_PI;
nav_sins.ref_params.eu_vh_base[0][0] = *eu_vh_roll;
nav_sins.ref_params.eu_vh_base[1][0] = *eu_vh_pitch;
nav_sins.ref_params.eu_vh_base[2][0] = *eu_vh_yaw;
nav_sins.ref_params.eu_vh_base[0][0] = *eu_vh_roll;
nav_sins.ref_params.eu_vh_base[1][0] = *eu_vh_pitch;
nav_sins.ref_params.eu_vh_base[2][0] = *eu_vh_yaw;
nav_sins.ref_params.zupt_source = *zupt_src;
nav_sins.ref_params.glrt_gamma = *gamma;
nav_sins.ref_params.glrt_acc_sigma = *acc_sigma;
nav_sins.ref_params.glrt_gyr_sigma = *gyr_sigma;
nav_sins.ref_params.glrt_n = *samples;
nav_sins.ref_params.sns_extr_en = *en_extr;
nav_sins.ref_params.sns_vel_th = *sns_v_th;
dbg_in_fill_gnss(this->gps);
prepare_data_gnss(this->gps);
dbg_in_fill_other(baro, odo, marg);
dbg_in_append_log();
prepare_data(baro, odo, marg);
nav_sins.run();
#if defined(BOARD_BEZVODIATEL)
if (NAV_RUN_STATIONARY_AUTONOMOUS == nav_sins.run_mode ||
NAV_RUN_STATIONARY_PRIMARY == nav_sins.run_mode) {
blue_led_on();
red_led_on();
} else {
blue_led_off();
red_led_off();
}
#endif
navi2acs();
navi2mavlink();
debug2mavlink();
dbg_out_fill(nav_sins.navi_data);
dbg_out_append_log();
stop_time_measurement(marg.dT);
}
static void *read_data(void *privdata)
{
struct dvb_open_descriptor *open_dev;
int timeout;
int ret, read_ret = -1, fd, i;
char databuf[REMOTE_BUF_SIZE];
char buf[REMOTE_BUF_SIZE + 32], *p;
size_t size;
size_t count;
struct pollfd __fds[NUM_FOPEN];
nfds_t __numfds;
timeout = 10; /* ms */
while (1) {
pthread_mutex_lock(&dvb_read_mutex);
if (!numfds) {
pthread_mutex_unlock(&dvb_read_mutex);
break;
}
__numfds = numfds;
memcpy(__fds, fds, sizeof(fds));
pthread_mutex_unlock(&dvb_read_mutex);
ret = poll(__fds, __numfds, timeout);
if (!ret)
continue;
if (ret < 0) {
err("poll");
continue;
}
for (i = 0; i < __numfds; i++) {
if (__fds[i].revents & (POLLERR | POLLHUP | POLLNVAL))
continue;
if (__fds[i].revents)
break;
}
/*
* it means that one error condition happened.
* Likely the file was closed.
*/
if (i == __numfds)
continue;
fd = __fds[i].fd;
if (!desc_root)
break;
open_dev = get_open_dev(fd);
if (!open_dev) {
err("Couldn't find opened file %d", fd);
continue;
}
count = REMOTE_BUF_SIZE;
read_ret = dvb_dev_read(open_dev, databuf, count);
if (verbose) {
if (read_ret < 0)
dbg("#%d: read error: %d on %p", fd, read_ret, open_dev);
else
dbg("#%d: read %d bytes (count %d)", fd, read_ret, count);
}
/* Initialize to the start of the buffer */
p = buf;
size = sizeof(buf);
ret = prepare_data(p, size, "%i%s%i%i", 0, "data_read",
read_ret, fd);
if (ret < 0) {
err("Failed to prepare answer to dvb_read()");
break;
}
p += ret;
size -= ret;
if (read_ret > 0) {
if (read_ret > size) {
dbg("buffer to short to store read data!");
read_ret = -EOVERFLOW;
} else {
memcpy(p, databuf, read_ret);
p += read_ret;
}
}
ret = send_buf(dvb_fd, buf, p - buf);
if (ret < 0) {
err("Error %d sending buffer\n", ret);
if (ret == ECONNRESET) {
close_all_devs();
break;
}
continue;
}
}
dbg("Finishing kthread");
read_id = 0;
return NULL;
}
static int dev_get_stats(uint32_t seq, char *cmd, int fd,
char *inbuf, ssize_t insize)
{
struct dvb_v5_fe_parms_priv *parms = (void *)dvb->fe_parms;
struct dvb_v5_stats *st = &parms->stats;
struct dvb_v5_fe_parms *par = (void *)parms;
int ret, i;
char buf[REMOTE_BUF_SIZE], *p = buf;
size_t size = sizeof(buf);
if (verbose)
dbg("dev_get_stats called");
ret = __dvb_fe_get_stats(par);
if (ret < 0)
goto error;
ret = prepare_data(p, size, "%i%s%i%i", seq, cmd, ret, st->prev_status);
if (ret < 0)
goto error;
p += ret;
size -= ret;
for (i = 0; i < DTV_NUM_STATS_PROPS; i++) {
ret = prepare_data(p, size, "%i%i",
st->prop[i].cmd,
st->prop[i].u.data);
if (ret < 0)
goto error;
p += ret;
size -= ret;
}
for (i = 0; i < MAX_DTV_STATS; i++) {
struct dvb_v5_counters *prev = st->prev;
struct dvb_v5_counters *cur = st->cur;
ret = prepare_data(p, size, "%i%i%i",
st->has_post_ber[i],
st->has_pre_ber[i],
st->has_per[i]);
if (ret < 0)
goto error;
p += ret;
size -= ret;
ret = prepare_data(p, size,
"%lu%lu%lu%lu%lu%lu%lu%lu%lu%lu%lu%lu",
prev->pre_bit_count,
prev->pre_bit_error,
prev->post_bit_count,
prev->post_bit_error,
prev->block_count,
prev->block_error,
cur->pre_bit_count,
cur->pre_bit_error,
cur->post_bit_count,
cur->post_bit_error,
cur->block_count,
cur->block_error);
if (ret < 0)
goto error;
p += ret;
size -= ret;
}
return send_buf(fd, buf, p - buf);
error:
return send_data(fd, "%i%s%i", seq, cmd, ret);
}
static int dev_get_parms(uint32_t seq, char *cmd, int fd,
char *inbuf, ssize_t insize)
{
struct dvb_v5_fe_parms_priv *parms = (void *)dvb->fe_parms;
struct dvb_v5_fe_parms *par = (void *)parms;
struct dvb_frontend_info *info = &par->info;
int ret, i;
char buf[REMOTE_BUF_SIZE], lnb_name[80] = "", *p = buf;
size_t size = sizeof(buf);
if (verbose)
dbg("dev_get_parms called");
ret = __dvb_fe_get_parms(par);
if (ret < 0)
goto error;
/* Send first the public params */
ret = prepare_data(p, size, "%i%s%i%s%i%i%i%i%i%i%i", seq, cmd, ret,
info->name, info->frequency_min,
info->frequency_max, info->frequency_stepsize,
info->frequency_tolerance, info->symbol_rate_min,
info->symbol_rate_max, info->symbol_rate_tolerance);
if (ret < 0)
goto error;
p += ret;
size -= ret;
if (par->lnb)
strcpy(lnb_name, par->lnb->name);
ret = prepare_data(p, size, "%i%i%i%i%i%i%i%s%i%i%i%i%s%s",
par->version, par->has_v5_stats, par->current_sys,
par->num_systems, par->legacy_fe, par->abort,
par->lna, lnb_name,
par->sat_number, par->freq_bpf, par->diseqc_wait,
par->verbose, par->default_charset,
par->output_charset);
if (ret < 0)
goto error;
p += ret;
size -= ret;
for (i = 0; i < MAX_DELIVERY_SYSTEMS; i++) {
ret = prepare_data(p, size, "%i", par->systems[i]);
if (ret < 0)
goto error;
p += ret;
size -= ret;
}
/* Now, send the private ones - except for stats */
ret = prepare_data(p, size, "%i%i%i%i",
parms->n_props,
parms->country,
parms->high_band,
parms->freq_offset);
if (ret < 0)
goto error;
p += ret;
size -= ret;
for (i = 0; i < parms->n_props; i++) {
ret = prepare_data(p, size, "%i%i",
parms->dvb_prop[i].cmd,
parms->dvb_prop[i].u.data);
if (ret < 0)
goto error;
p += ret;
size -= ret;
}
strcpy(output_charset, par->output_charset);
strcpy(default_charset, par->default_charset);
return send_buf(fd, buf, p - buf);
error:
return send_data(fd, "%i%s%i", seq, cmd, ret);
}
void
test_parse(gconstpointer data)
{
grn_obj *v;
prepare_data();
cond = grn_expr_create(&context, NULL, 0);
cut_assert_not_null(cond);
v = grn_expr_add_var(&context, cond, NULL, 0);
cut_assert_not_null(v);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs));
PARSE(cond, gcut_data_get_string(data, "query_hoge_moge"),
gcut_data_get_int(data, "query_hoge_moge_parse_level"));
PARSE(cond, gcut_data_get_string(data, "query_poyo"),
gcut_data_get_int(data, "query_poyo_parse_level"));
grn_expr_append_op(&context, cond, GRN_OP_AND, 2);
grn_test_assert_expr(
&context,
"#<expr\n"
" vars:{\n"
" $1:#<record:no_key:docs id:0(nonexistent)>\n"
" },\n"
" codes:{\n"
" 0:<get_value(), modify:2, "
"value:#<column:var_size docs.body range:Text type:scalar compress:none>>,\n"
" 1:<push(), modify:0, value:\"hoge\">,\n"
" 2:<match(), modify:4, value:(NULL)>,\n"
" 3:<get_value(), modify:2, "
"value:#<column:var_size docs.body range:Text type:scalar compress:none>>,\n"
" 4:<push(), modify:0, value:\"moge\">,\n"
" 5:<match(), modify:0, value:(NULL)>,\n"
" 6:<and(), modify:4, value:(NULL)>,\n"
" 7:<get_value(), modify:2, "
"value:#<column:var_size docs.body range:Text type:scalar compress:none>>,\n"
" 8:<push(), modify:0, value:\"poyo\">,\n"
" 9:<match(), modify:0, value:(NULL)>,\n"
" 10:<and(), modify:0, value:(NULL)>\n"
" }\n"
">",
cond);
res = grn_table_create(&context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, docs, NULL);
cut_assert_not_null(res);
cut_assert_not_null(grn_table_select(&context, docs, cond, res, GRN_OP_OR));
grn_test_assert_select(&context,
gcut_take_new_list_string("poyo moge hoge "
"moge moge moge",
NULL),
res,
"body");
grn_test_assert(grn_obj_close(&context, res));
res = NULL;
grn_test_assert(grn_obj_close(&context, cond));
cond = NULL;
cond = grn_expr_create(&context, NULL, 0);
cut_assert_not_null(cond);
v = grn_expr_add_var(&context, cond, NULL, 0);
cut_assert_not_null(v);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs));
PARSE(cond, gcut_data_get_string(data, "query_size"),
gcut_data_get_int(data, "query_size_parse_level"));
grn_test_assert_expr(
&context,
"#<expr\n"
" vars:{\n"
" $1:#<record:no_key:docs id:0(nonexistent)>\n"
" },\n"
" codes:{\n"
" 0:<get_value(), modify:2, "
"value:#<column:fix_size docs.size range:UInt32 type:scalar compress:none>>,\n"
" 1:<push(), modify:0, value:14>,\n"
" 2:<equal(), modify:0, value:(NULL)>\n"
" }\n"
">",
cond);
res = grn_table_create(&context, NULL, 0, NULL,
GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC, docs, NULL);
cut_assert_not_null(res);
cut_assert_not_null(grn_table_select(&context, docs, cond, res, GRN_OP_OR));
grn_test_assert_select(&context,
gcut_take_new_list_string("moge moge moge",
"hoge fuga fuga",
"moge hoge hoge",
NULL),
res,
"body");
}
void
test_select_search(void)
{
grn_obj *v;
prepare_data();
cut_assert_not_null((cond = grn_expr_create(&context, NULL, 0)));
v = grn_expr_add_var(&context, cond, NULL, 0);
GRN_RECORD_INIT(v, 0, grn_obj_id(&context, docs));
grn_expr_append_obj(&context, cond, v, GRN_OP_PUSH, 1);
GRN_TEXT_SETS(&context, &text_buf, "size");
grn_expr_append_const(&context, cond, &text_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, cond, GRN_OP_GET_VALUE, 2);
GRN_UINT32_SET(&context, &int_buf, 14);
grn_expr_append_const(&context, cond, &int_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, cond, GRN_OP_EQUAL, 2);
grn_expr_compile(&context, cond);
cut_assert_not_null((expr = grn_expr_create(&context, NULL, 0)));
v = grn_expr_add_var(&context, expr, NULL, 0);
grn_expr_append_obj(&context, expr, v, GRN_OP_PUSH, 1);
GRN_BULK_REWIND(&text_buf);
grn_expr_append_const(&context, expr, &text_buf, GRN_OP_PUSH, 1);
GRN_UINT32_SET(&context, &int_buf, GRN_TABLE_HASH_KEY|GRN_OBJ_WITH_SUBREC);
grn_expr_append_const(&context, expr, &int_buf, GRN_OP_PUSH, 1);
grn_expr_append_obj(&context, expr, docs, GRN_OP_PUSH, 1);
GRN_PTR_SET(&context, &ptr_buf, NULL);
grn_expr_append_obj(&context, expr, &ptr_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, expr, GRN_OP_TABLE_CREATE, 4);
grn_expr_append_op(&context, expr, GRN_OP_ASSIGN, 2);
grn_expr_append_obj(&context, expr, docs, GRN_OP_PUSH, 1);
grn_expr_append_obj(&context, expr, cond, GRN_OP_PUSH, 1);
grn_expr_append_obj(&context, expr, v, GRN_OP_PUSH, 1);
GRN_UINT32_SET(&context, &int_buf, GRN_OP_OR);
grn_expr_append_const(&context, expr, &int_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, expr, GRN_OP_TABLE_SELECT, 4);
grn_expr_append_obj(&context, expr, index_body, GRN_OP_PUSH, 1);
GRN_TEXT_SETS(&context, &text_buf, "moge");
grn_expr_append_const(&context, expr, &text_buf, GRN_OP_PUSH, 1);
grn_expr_append_obj(&context, expr, v, GRN_OP_PUSH, 1);
GRN_UINT32_SET(&context, &int_buf, GRN_OP_AND);
grn_expr_append_const(&context, expr, &int_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, expr, GRN_OP_OBJ_SEARCH, 4);
grn_expr_append_obj(&context, expr, v, GRN_OP_PUSH, 1);
GRN_TEXT_SETS(&context, &text_buf, ".size ._score .body");
grn_expr_append_const(&context, expr, &text_buf, GRN_OP_PUSH, 1);
GRN_BULK_REWIND(&text_buf);
grn_expr_append_obj(&context, expr, &text_buf, GRN_OP_PUSH, 1);
grn_expr_append_op(&context, expr, GRN_OP_JSON_PUT, 3);
grn_expr_exec(&context, expr, 0);
cut_assert_equal_substring("[[2],[14,4,\"moge moge moge\"],[14,2,\"moge hoge hoge\"]]",
GRN_TEXT_VALUE(&text_buf), GRN_TEXT_LEN(&text_buf));
}
int main(int argc, char **argv) {
MPI_Init(NULL, NULL);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
MPI_Comm_size(MPI_COMM_WORLD, &total_rank);
if(argc != 2) {
printf("Usage: test {mat_size}\n");
exit(-1);
}
size_t mat_size = atoi(argv[1]);
if (mat_size % total_rank) {
for (int i = 0; i < 20; i++)
printf("~");
printf("\n");
printf("Using MPT_*, only support divisible number of vertex...\n");
for (int i = 0; i < 20; i++)
printf("~");
printf("\n");
exit(-1);
}
int* mat;
int* ref;
int* result;
if (my_rank == 0) {
for (int i = 0; i < 20; i++)
printf("~");
printf("\n");
printf("Using MPT_*, only support divisible number of vertex...\n");
printf("Input size: %ld\n", mat_size);
printf("Total process: %d\n", total_rank);
prepare_data(&mat, &ref, &result, mat_size);
// start the timer
gettimeofday(&timer_parallel, NULL);
}
MPI_Barrier(MPI_COMM_WORLD);
// know the set of rows I am working on according to my_rank
int rows_in_charge = mat_size / total_rank;
// should this be included in the timer?
int* my_rows = (int*)malloc(sizeof(int) * mat_size * rows_in_charge); //rows the current process have
int* k_to_j = (int*)malloc(sizeof(int) * mat_size); // the vertical (column)
if (my_rank == 0)
gettimeofday(&timer_comm, NULL);
// divide the matrix for each process
// send rows to each process using scatter, sendbuf:*result, recvbuf:*my_rows
int sendrecvcount = mat_size * rows_in_charge;
MPI_Scatter(
result,
sendrecvcount,
MPI_INT,
my_rows,
sendrecvcount,
MPI_INT,
0,
MPI_COMM_WORLD);
if (my_rank == 0)
time_comm += get_time_and_replace(&timer_comm);
// preprocess_graph(my_rows, rows_in_charge, mat_size);
for (int k = 0; k < mat_size; k++) {
if (my_rank == 0)
gettimeofday(&timer_comm, NULL);
// broadcast k-th row to other process if I am the owner
int owner_of_k_row = k / rows_in_charge;
if (my_rank == owner_of_k_row)
memcpy(k_to_j, my_rows + mat_size * (k % rows_in_charge), sizeof(int) * mat_size);
MPI_Bcast(k_to_j, mat_size, MPI_INT, owner_of_k_row, MPI_COMM_WORLD);
if (my_rank == 0)
time_comm += get_time_and_replace(&timer_comm);
for (int i = 0; i < rows_in_charge; i++) {
for (int j = 0; j < mat_size; j++) {
int ij = i * mat_size + j;
int ik = i * mat_size + k;
// if (my_rows[ij] > ikj)
// my_rows[ij] = ikj;
if (my_rows[ik] != -1 && k_to_j[j] != -1) {
int ikj = my_rows[ik] + k_to_j[j];
if (my_rows[ij] == -1 || my_rows[ij] > ikj)
my_rows[ij] = ikj;
}
}
}
}
if (my_rank == 0)
gettimeofday(&timer_comm, NULL);
// collect result to process 0
MPI_Gather(
my_rows,
sendrecvcount,
MPI_INT,
result,
sendrecvcount,
MPI_INT,
0,
MPI_COMM_WORLD);
if (my_rank == 0)
time_comm += get_time_and_replace(&timer_comm);
if (my_rank == 0) {
//stop the timer
time_used_parallel = get_time_and_replace(&timer_parallel);
printf("Time used (parallel ): %8ld usecs\n", time_used_parallel);
printf("Time used (parallel ) comm : %6ld usecs (%2.3lf%%) \n", time_comm, time_comm / (double)time_used_parallel * 100);
printf("Speed up (sequential / parallel): %.3lf\n", time_used_sequential / (double)time_used_parallel);
//compare your result with reference result
if(CmpArray(result, ref, mat_size * mat_size))
printf("Your result is correct.\n");
else
printf("Your result is wrong.\n");
for (int i = 0; i < 20; i++)
printf("~");
printf("\n");
}
// Finalize the MPI environment.
MPI_Finalize();
}
static int
sinc_hex_vari_process (SRC_PRIVATE *psrc, SRC_DATA *data)
{ SINC_FILTER *filter ;
double input_index, src_ratio, count, float_increment, terminate, rem ;
increment_t increment, start_filter_index ;
int half_filter_chan_len, samples_in_hand ;
if (psrc->private_data == NULL)
return SRC_ERR_NO_PRIVATE ;
filter = (SINC_FILTER*) psrc->private_data ;
/* If there is not a problem, this will be optimised out. */
if (sizeof (filter->buffer [0]) != sizeof (data->data_in [0]))
return SRC_ERR_SIZE_INCOMPATIBILITY ;
filter->in_count = data->input_frames * filter->channels ;
filter->out_count = data->output_frames * filter->channels ;
filter->in_used = filter->out_gen = 0 ;
src_ratio = psrc->last_ratio ;
if (is_bad_src_ratio (src_ratio))
return SRC_ERR_BAD_INTERNAL_STATE ;
/* Check the sample rate ratio wrt the buffer len. */
count = (filter->coeff_half_len + 2.0) / filter->index_inc ;
if (MIN (psrc->last_ratio, data->src_ratio) < 1.0)
count /= MIN (psrc->last_ratio, data->src_ratio) ;
/* Maximum coefficientson either side of center point. */
half_filter_chan_len = filter->channels * (lrint (count) + 1) ;
input_index = psrc->last_position ;
float_increment = filter->index_inc ;
rem = fmod_one (input_index) ;
filter->b_current = (filter->b_current + filter->channels * lrint (input_index - rem)) % filter->b_len ;
input_index = rem ;
terminate = 1.0 / src_ratio + 1e-20 ;
/* Main processing loop. */
while (filter->out_gen < filter->out_count)
{
/* Need to reload buffer? */
samples_in_hand = (filter->b_end - filter->b_current + filter->b_len) % filter->b_len ;
if (samples_in_hand <= half_filter_chan_len)
{ if ((psrc->error = prepare_data (filter, data, half_filter_chan_len)) != 0)
return psrc->error ;
samples_in_hand = (filter->b_end - filter->b_current + filter->b_len) % filter->b_len ;
if (samples_in_hand <= half_filter_chan_len)
break ;
} ;
/* This is the termination condition. */
if (filter->b_real_end >= 0)
{ if (filter->b_current + input_index + terminate >= filter->b_real_end)
break ;
} ;
if (filter->out_count > 0 && fabs (psrc->last_ratio - data->src_ratio) > 1e-10)
src_ratio = psrc->last_ratio + filter->out_gen * (data->src_ratio - psrc->last_ratio) / filter->out_count ;
float_increment = filter->index_inc * (src_ratio < 1.0 ? src_ratio : 1.0) ;
increment = double_to_fp (float_increment) ;
start_filter_index = double_to_fp (input_index * float_increment) ;
calc_output_hex (filter, increment, start_filter_index, float_increment / filter->index_inc, data->data_out + filter->out_gen) ;
filter->out_gen += 6 ;
/* Figure out the next index. */
input_index += 1.0 / src_ratio ;
rem = fmod_one (input_index) ;
filter->b_current = (filter->b_current + filter->channels * lrint (input_index - rem)) % filter->b_len ;
input_index = rem ;
} ;
psrc->last_position = input_index ;
/* Save current ratio rather then target ratio. */
psrc->last_ratio = src_ratio ;
data->input_frames_used = filter->in_used / filter->channels ;
data->output_frames_gen = filter->out_gen / filter->channels ;
return SRC_ERR_NO_ERROR ;
} /* sinc_hex_vari_process */
int msu1_loop() {
/* it is assumed that the MSU file is already opened by calling msu1_check(). */
set_dac_vol(0x00);
while(fpga_status() & 0x4000);
uint16_t dac_addr = 0;
uint16_t msu_addr = 0;
uint8_t msu_repeat = 0;
uint16_t msu_track = 0;
uint32_t msu_offset = 0;
fpga_status_prev = fpga_status();
fpga_status_now = fpga_status();
int msu_res;
/* set_msu_addr(0x0);
msu_reset(0x0);
ff_sd_offload=1;
sd_offload_tgt=2;
f_lseek(&msufile, 0L);
ff_sd_offload=1;
sd_offload_tgt=2;
f_read(&msufile, file_buf, 16384, &msu_data_bytes_read);
*/
set_dac_addr(dac_addr);
dac_pause();
dac_reset();
set_msu_addr(0x0);
msu_reset(0x0);
ff_sd_offload=1;
sd_offload_tgt=2;
f_lseek(&msufile, 0L);
ff_sd_offload=1;
sd_offload_tgt=2;
f_read(&msufile, file_buf, 16384, &msu_data_bytes_read);
prepare_audio_track(0);
prepare_data(0);
/* audio_start, data_start, 0, audio_ctrl[1:0], ctrl_start */
while((msu_res = msu1_check_reset()) == MSU_RESET_NONE){
cli_entrycheck();
fpga_status_now = fpga_status();
/* Data buffer refill */
if((fpga_status_now & 0x2000) != (fpga_status_prev & 0x2000)) {
DBG_MSU1 printf("data\n");
uint8_t pageno = 0;
if(fpga_status_now & 0x2000) {
msu_addr = 0x0;
msu_page1_start = msu_page2_start + msu_page_size;
pageno = 1;
} else {
msu_addr = 0x2000;
msu_page2_start = msu_page1_start + msu_page_size;
pageno = 2;
}
set_msu_addr(msu_addr);
sd_offload_tgt=2;
ff_sd_offload=1;
msu_res = f_read(&msufile, file_buf, 8192, &msu_data_bytes_read);
DBG_MSU1 printf("data buffer refilled. res=%d page1=%08lx page2=%08lx\n", msu_res, msu_page1_start, msu_page2_start);
}
/* Audio buffer refill */
if((fpga_status_now & 0x4000) != (fpga_status_prev & 0x4000)) {
if(fpga_status_now & 0x4000) {
dac_addr = 0;
} else {
dac_addr = MSU_DAC_BUFSIZE/2;
}
set_dac_addr(dac_addr);
sd_offload_tgt=1;
ff_sd_offload=1;
f_read(&file_handle, file_buf, MSU_DAC_BUFSIZE/2, &msu_audio_bytes_read);
}
if(fpga_status_now & 0x0020) {
/* get trackno */
msu_track = get_msu_track();
DBG_MSU1 printf("Audio requested! Track=%d\n", msu_track);
prepare_audio_track(msu_track);
}
if(fpga_status_now & 0x0010) {
/* get address */
msu_offset=get_msu_offset();
prepare_data(msu_offset);
}
if(fpga_status_now & 0x0001) {
if(fpga_status_now & 0x0004) {
msu_repeat = 1;
set_msu_status(0x04, 0x01); /* set bit 2, reset bit 0 */
DBG_MSU1 printf("Repeat set!\n");
} else {
msu_repeat = 0;
set_msu_status(0x00, 0x05); /* set no bits, reset bit 0+2 */
DBG_MSU1 printf("Repeat clear!\n");
}
if(fpga_status_now & 0x0002) {
DBG_MSU1 printf("PLAY!\n");
set_msu_status(0x02, 0x01); /* set bit 0, reset bit 1 */
dac_play();
} else {
DBG_MSU1 printf("PAUSE!\n");
set_msu_status(0x00, 0x03); /* set no bits, reset bit 1+0 */
dac_pause();
}
}
fpga_status_prev = fpga_status_now;
/* handle loop / end */
if(msu_audio_bytes_read < MSU_DAC_BUFSIZE / 2) {
ff_sd_offload=0;
sd_offload=0;
if(msu_repeat) {
DBG_MSU1 printf("loop\n");
ff_sd_offload=1;
sd_offload_tgt=1;
f_lseek(&file_handle, 8L+msu_loop_point*4);
ff_sd_offload=1;
sd_offload_tgt=1;
f_read(&file_handle, file_buf, (MSU_DAC_BUFSIZE / 2) - msu_audio_bytes_read, &msu_audio_bytes_read);
} else {
set_msu_status(0x00, 0x02); /* clear play bit */
dac_pause();
}
msu_audio_bytes_read = MSU_DAC_BUFSIZE;
}
}
f_close(&file_handle);
DBG_MSU1 printf("Reset ");
if(msu_res == MSU_RESET_LONG) {
f_close(&msufile);
DBG_MSU1 printf("to menu\n");
return 1;
}
DBG_MSU1 printf("game\n");
return 0;
}
/*! \brief Start of execution. Parse options, and call other other
* functions one after another. At the moment adding threading support
* would be difficult, but there does not seem to be valid reason to
* consider that. Overall the analysis already quick enough even without
* making it parallel.
*
* \return Return value indicates success or fail or analysis, unless
* either --warning or --critical options are in use, which makes the
* return value in some cases to match with Nagios expectations about
* alarming. */
int main(int argc, char **argv)
{
int i, sorts = 0;
int option_index = 0;
char const *tmp;
struct range_t *tmp_ranges;
enum {
OPT_WARN = CHAR_MAX + 1,
OPT_CRIT
};
int ret_val;
/* Options for getopt_long */
static struct option const long_options[] = {
{"config", required_argument, NULL, 'c'},
{"leases", required_argument, NULL, 'l'},
{"format", required_argument, NULL, 'f'},
{"sort", required_argument, NULL, 's'},
{"reverse", no_argument, NULL, 'r'},
{"output", required_argument, NULL, 'o'},
{"limit", required_argument, NULL, 'L'},
{"version", no_argument, NULL, 'v'},
{"help", no_argument, NULL, 'h'},
{"warning", required_argument, NULL, OPT_WARN},
{"critical", required_argument, NULL, OPT_CRIT},
{NULL, 0, NULL, 0}
};
atexit(close_stdout);
/* FIXME: These allocations should be fully dynamic, e.g., grow
* if needed. */
config.dhcpdconf_file = xmalloc(sizeof(char) * MAXLEN);
config.dhcpdlease_file = xmalloc(sizeof(char) * MAXLEN);
config.output_file = xmalloc(sizeof(char) * MAXLEN);
/* Make sure string has zero length if there is no
* command line option */
config.output_file[0] = '\0';
/* Alarming defaults. */
config.warning = ALARM_WARN;
config.critical = ALARM_CRIT;
/* File location defaults */
strncpy(config.dhcpdconf_file, DHCPDCONF_FILE, MAXLEN - 1);
strncpy(config.dhcpdlease_file, DHCPDLEASE_FILE, MAXLEN - 1);
tmp = OUTPUT_LIMIT;
config.output_limit[0] = (*tmp - '0');
tmp++;
config.output_limit[1] = (*tmp - '0');
config.fullhtml = false;
/* Make sure some output format is selected by default */
strncpy(config.output_format, OUTPUT_FORMAT, (size_t)1);
/* Default sort order is by IPs small to big */
config.reverse_order = false;
config.backups_found = false;
/* Parse command line options */
while (1) {
int c;
c = getopt_long(argc, argv, "c:l:f:o:s:rL:vh",
long_options, &option_index);
if (c == EOF)
break;
switch (c) {
case 'c':
/* config file */
strncpy(config.dhcpdconf_file, optarg, MAXLEN - 1);
break;
case 'l':
/* lease file */
strncpy(config.dhcpdlease_file, optarg, MAXLEN - 1);
break;
case 'f':
/* Output format */
strncpy(config.output_format, optarg, (size_t)1);
break;
case 's':
/* Output sorting option */
sorts = strlen(optarg);
if (5 < sorts) {
warnx
("main: only first 5 sort orders will be used");
strncpy(config.sort, optarg, (size_t)5);
sorts = 5;
} else {
strncpy(config.sort, optarg, (size_t)sorts);
}
for (i = 0; i < sorts; i++) {
field_selector(config.sort[i]);
}
break;
case 'r':
/* What ever sort in reverse order */
config.reverse_order = true;
break;
case 'o':
/* Output file */
strncpy(config.output_file, optarg, MAXLEN - 1);
break;
case 'L':
/* Specification what will be printed */
for (i = 0; i < 2; i++) {
if (optarg[i] >= '0' && optarg[i] < '8') {
config.output_limit[i] =
optarg[i] - '0';
} else {
errx(EXIT_FAILURE,
"main: output mask `%s' is illegal",
optarg);
}
}
break;
case OPT_WARN:
strcpy(config.output_format, "a");
config.warning =
strtod_or_err(optarg, "illegal argument");
break;
case OPT_CRIT:
strcpy(config.output_format, "a");
config.critical =
strtod_or_err(optarg, "illegal argument");
break;
case 'v':
/* Print version */
print_version();
case 'h':
/* Print help */
usage(EXIT_SUCCESS);
default:
errx(EXIT_FAILURE,
"Try `%s --help' for more information.",
program_invocation_short_name);
}
}
/* Output function selection */
switch (config.output_format[0]) {
case 't':
output_analysis = output_txt;
break;
case 'a':
output_analysis = output_alarming;
break;
case 'h':
output_analysis = output_html;
break;
case 'H':
output_analysis = output_html;
config.fullhtml = true;
break;
case 'x':
output_analysis = output_xml;
break;
case 'X':
output_analysis = output_xml;
break;
case 'j':
output_analysis = output_json;
break;
case 'J':
output_analysis = output_json;
break;
case 'c':
output_analysis = output_csv;
break;
default:
errx(EXIT_FAILURE, "main: unknown output format `%c'",
config.output_format[0]);
}
/* Do the job */
prepare_memory();
parse_config(true, config.dhcpdconf_file, shared_networks);
parse_leases();
prepare_data();
do_counting();
tmp_ranges = xmalloc(sizeof(struct range_t) * num_ranges);
if (sorts != 0) {
mergesort_ranges(ranges, num_ranges, tmp_ranges);
}
if (config.reverse_order == true) {
flip_ranges(ranges, tmp_ranges);
}
free(tmp_ranges);
ret_val = output_analysis();
clean_up();
return (ret_val);
}
void Manager::start() {
prepare_data();
prepare_parsers();
parse();
}