char *getfile(char *filename) {
assert(filename != NULL);
unsigned buff_len = 0;
unsigned buff_cap = GETFILE_BUF_SIZE;
char *buff = NULL;
char *temp = NULL;
FILE *f = NULL;
buff = (char*)malloc(sizeof(char)*buff_cap);
error_goto_if(buff == NULL, "getfile(%s): Out of (malloc) memory.", filename);
// Open file
f = fopen(filename, "r");
error_goto_if(f == NULL, "getfile(%s): Cannot open.\n", filename);
while (1) {
buff_len += fread(&buff[buff_len], sizeof(char), GETFILE_BUF_SIZE, f);
if (feof(f)) {
// Try to do a downward realloc.
temp = (char*)realloc(buff, sizeof(char) * (buff_len+1));
if (temp == NULL) {
warn("getfile(%s): downward realloc failed.", filename);
} else {
buff = temp;
}
buff[buff_len] = 0; // null terminate the char *
break;
}
error_goto_if(ferror(f), "getfile(%s): ferror() while reading; errno: %s", filename, strerror(errno));
// Ensure there is always at least FREAD_BUF_SIZE space to read into
if ((buff_cap - buff_len) < GETFILE_BUF_SIZE) {
buff_cap = buff_len + (buff_cap - buff_len) + GETFILE_BUF_SIZE;
temp = (char*)realloc(buff, sizeof(char)*buff_cap);
error_goto_if(temp == NULL, "getfile(%s): Out of (realloc) memory.", filename);
buff = temp;
}
}
warn_if(fclose(f), "getfile(%s): cannot close.\n", filename);
return buff;
error:
if (buff) { free(buff); }
if (f) { warn_if(fclose(f), "getfile(%s): cannot close.\n", filename); }
return NULL;
}
int cals_end_trans(bool is_success)
{
int ret;
int progress = 0;
char query[CALS_SQL_MIN_LEN];
transaction_cnt--;
if (0 != transaction_cnt) {
CALS_DBG("transaction_cnt : %d", transaction_cnt);
return CAL_SUCCESS;
}
if (false == is_success) {
_cals_cancel_changes();
ret = cals_query_exec("ROLLBACK TRANSACTION");
return CAL_SUCCESS;
}
if (version_up) {
transaction_ver++;
snprintf(query, sizeof(query), "UPDATE %s SET ver = %d",
CALS_TABLE_VERSION, transaction_ver);
ret = cals_query_exec(query);
warn_if(CAL_SUCCESS != ret, "cals_query_exec(version up) Failed(%d).", ret);
}
progress = 400000;
ret = cals_query_exec("COMMIT TRANSACTION");
while (CAL_ERR_DB_LOCK == ret && progress < CAL_COMMIT_TRY_MAX) {
usleep(progress);
ret = cals_query_exec("COMMIT TRANSACTION");
progress *= 2;
}
if (CAL_SUCCESS != ret) {
int tmp_ret;
ERR("cals_query_exec() Failed(%d)", ret);
_cals_cancel_changes();
tmp_ret = cals_query_exec("ROLLBACK TRANSACTION");
warn_if(CAL_SUCCESS != tmp_ret, "cals_query_exec(ROLLBACK) Failed(%d).", tmp_ret);
return ret;
}
if (event_change) _cals_notify_event_change();
if (todo_change) _cals_notify_todo_change();
if (calendar_change) _cals_notify_calendar_change();
return transaction_ver;
}
dg_angle dg_p_atan2(dg_p y, dg_p x) {
warn_if(x & ~(dg_p)~(dg_qtan)0
|| y & ~(dg_p)~(dg_qtan)0
&& "Whoops, y, x or both use more bits than dg_qtan can take!\n"
"(Your physics simulation probably needs too many units).\n"
"You should take care that it doesn't happen.");
return dg_qtan_atan(dg_qtan_div(y, x));
}
static void
_warning(struct type_5_parser_context *ctx, const char *msg, ...)
{
warn_if(!ctx, "ctx is NULL");
va_list args;
va_start(args, msg);
vprintf(msg, args);
va_end(args);
}
int cts_normalize_name(cts_name *src,
char dest[][CTS_SQL_MAX_LEN], bool is_display)
{
int ret;
if (is_display) {
ret = cts_remove_special_char(src->display, dest[CTS_NN_FIRST],
sizeof(dest[CTS_NN_FIRST]));
warn_if(ret < CTS_SUCCESS, "cts_remove_special_char() Failed(%d)", ret);
snprintf(dest[CTS_NN_SORTKEY], sizeof(dest[CTS_NN_SORTKEY]), "%s", dest[CTS_NN_FIRST]);
ret = CTS_SUCCESS;
}
else {
ret = cts_remove_special_char(src->first, dest[CTS_NN_FIRST],
sizeof(dest[CTS_NN_FIRST]));
warn_if(ret < CTS_SUCCESS, "cts_remove_special_char() Failed(%d)", ret);
ret = CTS_SUCCESS;
ret = cts_remove_special_char(src->last, dest[CTS_NN_LAST],
sizeof(dest[CTS_NN_LAST]));
warn_if(ret < CTS_SUCCESS, "cts_remove_special_char() Failed(%d)", ret);
ret = CTS_SUCCESS;
if (!*dest[CTS_NN_LAST])
snprintf(dest[CTS_NN_SORTKEY], sizeof(dest[CTS_NN_SORTKEY]), "%s", dest[CTS_NN_FIRST]);
else if (!*dest[CTS_NN_FIRST])
snprintf(dest[CTS_NN_SORTKEY], sizeof(dest[CTS_NN_SORTKEY]), "%s", dest[CTS_NN_LAST]);
else if (CTS_ORDER_NAME_FIRSTLAST == contacts_svc_get_order(CTS_ORDER_OF_DISPLAY))
snprintf(dest[CTS_NN_SORTKEY], sizeof(dest[CTS_NN_SORTKEY]), "%s %s", dest[CTS_NN_FIRST], dest[CTS_NN_LAST]);
else
snprintf(dest[CTS_NN_SORTKEY], sizeof(dest[CTS_NN_SORTKEY]), "%s, %s", dest[CTS_NN_LAST], dest[CTS_NN_FIRST]);
}
if (extra_normalize_fn)
ret = extra_normalize_fn(dest);
else {
cts_mutex_lock(CTS_MUTEX_SOCKET_FD);
ret = cts_request_normalize_name(dest);
cts_mutex_unlock(CTS_MUTEX_SOCKET_FD);
}
return ret;
}
MeshFunctionSharedPtr<Scalar> Limiter<Scalar>::get_solution()
{
// A check.
warn_if(this->component_count > 1, "One solution asked from a Limiter, but multiple solutions exist for limiting.");
MeshFunctionSharedPtr<Scalar> solution(new Solution<Scalar>());
Hermes::vector<MeshFunctionSharedPtr<Scalar> > solutions;
solutions.push_back(solution);
this->get_solutions(solutions);
return solutions.back();
}
int cts_inotify_unsubscribe(const char *path, void (*cb)(void *))
{
int ret, wd;
retv_if(NULL == path, CTS_ERR_ARG_NULL);
retvm_if(cts_inoti_fd < 0, CTS_ERR_ENV_INVALID,
"cts_inoti_fd(%d) is invalid", cts_inoti_fd);
wd = cts_inotify_get_wd(cts_inoti_fd, path);
retvm_if(-1 == wd, CTS_ERR_INOTIFY_FAILED,
"cts_inotify_get_wd() Failed(%d)", errno);
ret = del_noti(&cts_noti_list, wd, cb);
warn_if(ret < CTS_SUCCESS, "del_noti() Failed(%d)", ret);
if (0 == ret)
return inotify_rm_watch(cts_inoti_fd, wd);
return cts_inotify_watch(cts_inoti_fd, path);
}
void ProjBasedSelector::calc_projection_errors(Element* e, const CandsInfo& info_h, const CandsInfo& info_p, const CandsInfo& info_aniso, Solution* rsln, CandElemProjError herr[4], CandElemProjError perr, CandElemProjError anisoerr[4]) {
assert_msg(info_h.is_empty() || (H2D_GET_H_ORDER(info_h.max_quad_order) <= H2DRS_MAX_ORDER && H2D_GET_V_ORDER(info_h.max_quad_order) <= H2DRS_MAX_ORDER), "Maximum allowed order of a son of H-candidate is %d but order (H:%d,V:%d) requested.", H2DRS_MAX_ORDER, H2D_GET_H_ORDER(info_h.max_quad_order), H2D_GET_V_ORDER(info_h.max_quad_order));
assert_msg(info_p.is_empty() || (H2D_GET_H_ORDER(info_p.max_quad_order) <= H2DRS_MAX_ORDER && H2D_GET_V_ORDER(info_p.max_quad_order) <= H2DRS_MAX_ORDER), "Maximum allowed order of a son of P-candidate is %d but order (H:%d,V:%d) requested.", H2DRS_MAX_ORDER, H2D_GET_H_ORDER(info_p.max_quad_order), H2D_GET_V_ORDER(info_p.max_quad_order));
assert_msg(info_aniso.is_empty() || (H2D_GET_H_ORDER(info_aniso.max_quad_order) <= H2DRS_MAX_ORDER && H2D_GET_V_ORDER(info_aniso.max_quad_order) <= H2DRS_MAX_ORDER), "Maximum allowed order of a son of ANISO-candidate is %d but order (H:%d,V:%d) requested.", H2DRS_MAX_ORDER, H2D_GET_H_ORDER(info_aniso.max_quad_order), H2D_GET_V_ORDER(info_aniso.max_quad_order));
int mode = e->get_mode();
// select quadrature, obtain integration points and weights
Quad2D* quad = &g_quad_2d_std;
quad->set_mode(mode);
rsln->set_quad_2d(quad);
double3* gip_points = quad->get_points(H2DRS_INTR_GIP_ORDER);
int num_gip_points = quad->get_num_points(H2DRS_INTR_GIP_ORDER);
// everything is done on the reference domain
rsln->enable_transform(false);
// obtain reference solution values on all four refined sons
scalar** rval[H2D_MAX_ELEMENT_SONS];
Element* base_element = rsln->get_mesh()->get_element(e->id);
assert(!base_element->active);
for (int son = 0; son < H2D_MAX_ELEMENT_SONS; son++)
{
//set element
Element* e = base_element->sons[son];
assert(e != NULL);
//obtain precalculated values
rval[son] = precalc_ref_solution(son, rsln, e, H2DRS_INTR_GIP_ORDER);
}
//retrieve transformations
Trf* trfs = NULL;
int num_noni_trfs = 0;
if (mode == HERMES_MODE_TRIANGLE) {
trfs = tri_trf;
num_noni_trfs = H2D_TRF_TRI_NUM;
}
else {
trfs = quad_trf;
num_noni_trfs = H2D_TRF_QUAD_NUM;
}
// precalculate values of shape functions
TrfShape empty_shape_vals;
if (!cached_shape_vals_valid[mode]) {
precalc_ortho_shapes(gip_points, num_gip_points, trfs, num_noni_trfs, shape_indices[mode], max_shape_inx[mode], cached_shape_ortho_vals[mode]);
precalc_shapes(gip_points, num_gip_points, trfs, num_noni_trfs, shape_indices[mode], max_shape_inx[mode], cached_shape_vals[mode]);
cached_shape_vals_valid[mode] = true;
//issue a warning if ortho values are defined and the selected cand_list might benefit from that but it cannot because elements do not have uniform orders
if (!warn_uniform_orders && mode == HERMES_MODE_QUAD && !cached_shape_ortho_vals[mode][H2D_TRF_IDENTITY].empty()) {
warn_uniform_orders = true;
if (cand_list == H2D_H_ISO || cand_list == H2D_H_ANISO || cand_list == H2D_P_ISO || cand_list == H2D_HP_ISO || cand_list == H2D_HP_ANISO_H) {
warn_if(!info_h.uniform_orders || !info_aniso.uniform_orders || !info_p.uniform_orders, "Possible inefficiency: %s might be more efficient if the input mesh contains elements with uniform orders strictly.", get_cand_list_str(cand_list));
}
}
}
TrfShape& svals = cached_shape_vals[mode];
TrfShape& ortho_svals = cached_shape_ortho_vals[mode];
//H-candidates
if (!info_h.is_empty()) {
Trf* p_trf_identity[1] = { &trfs[H2D_TRF_IDENTITY] };
std::vector<TrfShapeExp>* p_trf_svals[1] = { &svals[H2D_TRF_IDENTITY] };
std::vector<TrfShapeExp>* p_trf_ortho_svals[1] = { &ortho_svals[H2D_TRF_IDENTITY] };
for(int son = 0; son < H2D_MAX_ELEMENT_SONS; son++) {
scalar **sub_rval[1] = { rval[son] };
calc_error_cand_element(mode, gip_points, num_gip_points
, 1, &base_element->sons[son], p_trf_identity, sub_rval
, p_trf_svals, p_trf_ortho_svals
, info_h, herr[son]);
}
}
//ANISO-candidates
if (!info_aniso.is_empty()) {
const int sons[4][2] = { {0,1}, {3,2}, {0,3}, {1,2} }; //indices of sons for sub-areas
const int tr[4][2] = { {6,7}, {6,7}, {4,5}, {4,5} }; //indices of ref. domain transformations for sub-areas
for(int version = 0; version < 4; version++) { // 2 elements for vertical split, 2 elements for horizontal split
Trf* sub_trfs[2] = { &trfs[tr[version][0]], &trfs[tr[version][1]] };
Element* sub_domains[2] = { base_element->sons[sons[version][0]], base_element->sons[sons[version][1]] };
scalar **sub_rval[2] = { rval[sons[version][0]], rval[sons[version][1]] };
std::vector<TrfShapeExp>* sub_svals[2] = { &svals[tr[version][0]], &svals[tr[version][1]] };
std::vector<TrfShapeExp>* sub_ortho_svals[2] = { &ortho_svals[tr[version][0]], &ortho_svals[tr[version][1]] };
calc_error_cand_element(mode, gip_points, num_gip_points
, 2, sub_domains, sub_trfs, sub_rval
, sub_svals, sub_ortho_svals
, info_aniso, anisoerr[version]);
}
}
//P-candidates
if (!info_p.is_empty()) {
Trf* sub_trfs[4] = { &trfs[0], &trfs[1], &trfs[2], &trfs[3] };
scalar **sub_rval[4] = { rval[0], rval[1], rval[2], rval[3] };
std::vector<TrfShapeExp>* sub_svals[4] = { &svals[0], &svals[1], &svals[2], &svals[3] };
std::vector<TrfShapeExp>* sub_ortho_svals[4] = { &ortho_svals[0], &ortho_svals[1], &ortho_svals[2], &ortho_svals[3] };
calc_error_cand_element(mode, gip_points, num_gip_points
, 4, base_element->sons, sub_trfs, sub_rval
, sub_svals, sub_ortho_svals
, info_p, perr);
}
}
int cals_update_schedule(const int index, cal_sch_full_t *sch_record)
{
bool is_success = false;
cal_value * cvalue = NULL;
int ret = 0;
int rrule_id = 0;
retv_if(NULL == sch_record, CAL_ERR_ARG_NULL);
sch_record->missed = 0;
ret = _cals_update_schedule(index, sch_record);
retvm_if(CAL_SUCCESS != ret, ret, "_cals_update_schedule() Failed(%d)", ret);
if (sch_record->freq != CALS_FREQ_ONCE) {
ret = _cals_get_rrule_id(index, &rrule_id);
if (rrule_id > 0) {
ret = _cals_update_rrule(index, sch_record);
retvm_if(CAL_SUCCESS != ret, ret, "Failed in update rrule(%d)", ret);
} else {
ret = _cals_insert_rrule(index, sch_record);
if (ret < CAL_SUCCESS) {
ERR("Failed in _cals_insert_rrule(%d)\n", ret);
return ret;
}
sch_record->rrule_id = ret;
DBG("added rrule_id(%d)", ret);
ret = _cals_insert_rrule_id(index, sch_record);
if (ret != CAL_SUCCESS) {
ERR("Failed in _cals_insert_rrule_id(%d)\n", ret);
}
DBG("ended add");
}
}
_cals_delete_participant_info(index);
if (sch_record->attendee_list)
{
GList *list = g_list_first(sch_record->attendee_list);
cal_participant_info_t* participant_info = NULL;
while(list)
{
cvalue = (cal_value *)list->data;
participant_info = (cal_participant_info_t*)cvalue->user_data;
if (0 == participant_info->is_deleted) {
ret = cal_service_add_participant_info(index, participant_info);
warn_if(ret, "cal_service_add_participant_info() Failed(%d)", ret);
}
list = g_list_next(list);
}
}
/* delete registered alarm */
cals_alarm_remove(CALS_ALARM_REMOVE_BY_EVENT_ID, index);
if (sch_record->alarm_list)
{
GList *list = sch_record->alarm_list;
cal_alarm_info_t *alarm_info = NULL;
struct cals_time dtstart;
while (list)
{
cvalue = (cal_value *)list->data;
alarm_info = (cal_alarm_info_t*)cvalue->user_data;
if (alarm_info->is_deleted==0) {
if (alarm_info->remind_tick != CALS_INVALID_ID) {
dtstart.type = sch_record->dtstart_type;
dtstart.utime = sch_record->dtstart_utime;
dtstart.year = sch_record->dtstart_year;
dtstart.month = sch_record->dtstart_month;
dtstart.mday = sch_record->dtstart_mday;
ret = cals_alarm_add(index, alarm_info, &dtstart);
warn_if(CAL_SUCCESS != ret, "cals_alarm_add() Failed(%d)", ret);
}
}
list = g_list_next(list);
}
}
/* TODO: re register alarm */
/* clear instance */
ret = _cals_clear_instances(index);
if (ret) {
ERR("_cals_clear_instances failed (%d)", ret);
return ret;
}
/* insert instance */
struct cals_time st;
struct cals_time et;
st.type = sch_record->dtstart_type;
if (st.type == CALS_TIME_UTIME)
st.utime = sch_record->dtstart_utime;
else {
st.year = sch_record->dtstart_year;
st.month = sch_record->dtstart_month;
st.mday = sch_record->dtstart_mday;
}
et.type = sch_record->dtend_type;
if (et.type == CALS_TIME_UTIME)
et.utime = sch_record->dtend_utime;
else {
et.year = sch_record->dtend_year;
et.month = sch_record->dtend_month;
et.mday = sch_record->dtend_mday;
}
cals_instance_insert(index, &st, &et, sch_record);
/* set notify */
if(sch_record->cal_type == CALS_SCH_TYPE_EVENT)
is_success= cals_notify(CALS_NOTI_TYPE_EVENT);
else
is_success= cals_notify(CALS_NOTI_TYPE_TODO);
return CAL_SUCCESS;
}
int cals_insert_schedule(cal_sch_full_t *sch_record)
{
int ret = 0;
int index = 0;
cal_value *cvalue = NULL;
bool is_success = false;
struct cals_time st;
struct cals_time et;
retvm_if(NULL == sch_record, CAL_ERR_ARG_INVALID, "sch_record is NULL");
sch_record->missed = 0;
ret = cals_begin_trans();
retvm_if(ret, ret, "cals_begin_trans() is Failed(%d)", ret);
ret = _cals_insert_schedule(sch_record);
if(ret < CAL_SUCCESS) {
ERR("_cals_insert_schedule() Failed(%d)", ret);
cals_end_trans(false);
return ret;
}
index = ret;
if (sch_record->freq != CALS_FREQ_ONCE) {
ret = _cals_insert_rrule(index, sch_record);
if (ret < CAL_SUCCESS) {
ERR("Failed in _cals_insert_rrule(%d)\n", ret);
cals_end_trans(false);
return ret;
}
sch_record->rrule_id = ret;
DBG("added rrule_id(%d)", ret);
ret = _cals_insert_rrule_id(index, sch_record);
if (ret != CAL_SUCCESS) {
ERR("Failed in _cals_insert_rrule_id(%d)\n", ret);
}
DBG("ended add");
}
st.type = sch_record->dtstart_type;
if (st.type == CALS_TIME_UTIME)
st.utime = sch_record->dtstart_utime;
else {
st.year = sch_record->dtstart_year;
st.month = sch_record->dtstart_month;
st.mday = sch_record->dtstart_mday;
}
et.type = sch_record->dtend_type;
if (et.type == CALS_TIME_UTIME)
et.utime = sch_record->dtend_utime;
else {
et.year = sch_record->dtend_year;
et.month = sch_record->dtend_month;
et.mday = sch_record->dtend_mday;
}
cals_instance_insert(index, &st, &et, sch_record);
if (sch_record->attendee_list)
{
DBG("attendee exists");
GList *list = g_list_first(sch_record->attendee_list);
cal_participant_info_t *participant_info = NULL;
while(list)
{
cvalue = list->data;
if(cvalue)
{
participant_info = cvalue->user_data;
if(participant_info->is_deleted==0)
{
ret = cal_service_add_participant_info(index, participant_info);
warn_if(ret, "cal_service_add_participant_info() Failed(%d)", ret);
}
}
list = g_list_next(list);
}
} else {
DBG("No attendee exists");
}
if (sch_record->alarm_list)
{
DBG("alarm exists");
GList *list = sch_record->alarm_list;
cal_alarm_info_t *alarm_info = NULL;
while (list)
{
cvalue = list->data;
if (cvalue == NULL) {
ERR("Failed to fine value");
break;
}
alarm_info = cvalue->user_data;
if (alarm_info == NULL) {
ERR("Failed to find alarm info");
break;
}
if(alarm_info->is_deleted == 0)
{
DBG("type(%d) tick(%d) unit(%d)",
sch_record->cal_type,
alarm_info->remind_tick,
alarm_info->remind_tick_unit);
if (alarm_info->remind_tick != CALS_INVALID_ID)
{
switch (sch_record->cal_type) {
case CALS_SCH_TYPE_EVENT:
ret = cals_alarm_add(index, alarm_info, &st);
warn_if(CAL_SUCCESS != ret, "cals_alarm_add() Failed(%d)", ret);
break;
case CALS_SCH_TYPE_TODO:
if (sch_record->dtend_utime == CALS_TODO_NO_DUE_DATE) {
DBG("no due date is set");
break;
}
ret = cals_alarm_add(index, alarm_info, &et);
warn_if(CAL_SUCCESS != ret, "cals_alarm_add() Failed(%d)", ret);
break;
}
}
}
list = list->next;
}
} else {
DBG("No alarm exists");
}
cals_end_trans(true);
sch_record->index = index;
if(sch_record->cal_type == CALS_SCH_TYPE_EVENT)
is_success= cals_notify(CALS_NOTI_TYPE_EVENT);
else
is_success= cals_notify(CALS_NOTI_TYPE_TODO);
warn_if(is_success != CAL_SUCCESS, "cals_notify() Failed");
return index;
}
static xmlEntityPtr
_get_entity(struct type_5_parser_context *ctx, const xmlChar *name)
{
warn_if(!ctx, "ctx is NULL");
return xmlGetPredefinedEntity(name);
}
