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); }