void gfal2_test_gfal_select_best_protocol_and_endpointG() { char endpoint[2048]; memset(endpoint, '\0', sizeof(char)*2048); enum gfal_srm_proto srm_type; GError * err= NULL; gfal_handle handle = gfal_initG(&err); assert_true_with_message(handle != NULL, " handle is not properly allocated"); if(handle==NULL) return; gfal_plugins_instance(handle, NULL); gfal_srmv2_opt opts; gfal_srm_opt_initG(&opts, handle); gfal_set_default_storageG(&opts, PROTO_SRMv2); char* endpoint_list[] = { "everest", "montblanc", NULL}; char* se_type_list[] = { "srm_v1", "srm_v2", NULL }; int ret = gfal_select_best_protocol_and_endpointG(&opts, se_type_list, endpoint_list, endpoint, 2048, &srm_type, &err); assert_true_with_message(ret ==0 && err == NULL, " must be a succefull call to the best select"); gfal_check_GError(&err); assert_true_with_message(strings_are_equal(endpoint,"montblanc"), " reponse not match correctly"); // try with another version by default gfal_set_default_storageG(&opts, PROTO_SRM); ret = gfal_select_best_protocol_and_endpointG(&opts, se_type_list, endpoint_list, endpoint, 2048, &srm_type, &err); assert_true_with_message(ret ==0 && err == NULL, " must be a succefull call to the best select"); gfal_check_GError(&err); assert_true_with_message(strings_are_equal(endpoint,"everest") , "must be a valid check"); gfal_handle_freeG(handle); }
void gfal2_test_gfal_auto_get_srm_endpoint_full_endpoint_with_no_bdiiG() { #if USE_MOCK setup_mock_bdii(); #endif GError* err = NULL; char buff_endpoint[2048]; enum gfal_srm_proto proto; gfal_handle handle = gfal_initG(&err); assert_true_with_message(handle != NULL, " handle is not properly allocated"); if(handle==NULL) return; gfal_plugins_instance(handle, NULL); gfal_srmv2_opt opts; gfal_srm_opt_initG(&opts, handle); gfal_set_nobdiiG(handle, TRUE); int ret =-1; ret = gfal_srm_determine_endpoint(&opts, TEST_SRM_DPM_FULLENDPOINT_PREFIX, buff_endpoint, 2048, &proto, &err); assert_true_with_message( ret ==0 && err == NULL && strings_are_equal(buff_endpoint, TEST_SRM_DPM_FULLENDPOINT_URL), " must be a succesfull endpoint determination %d %ld %s", ret, err, buff_endpoint); gfal_check_GError(&err); ret = gfal_srm_determine_endpoint(&opts, "srm://srm-pps:8443/srm/managerv2?SFN=/castor/cern.ch/grid/dteam/castordev/test-srm-pps_8443-srm2_d0t1-ed6b7013-5329-4f5b", buff_endpoint, 2048, &proto, &err); assert_true_with_message( ret ==0 && err == NULL && strings_are_equal(buff_endpoint, "httpg://srm-pps:8443/srm/managerv2"), " must be a succesfull endpoint determination 2 %d %ld %s", ret, err, buff_endpoint); gfal_check_GError(&err); memset(buff_endpoint,0, sizeof(char)*2048); ret = gfal_srm_determine_endpoint(&opts, TEST_SRM_VALID_SURL_EXAMPLE1, buff_endpoint, 2048, &proto, &err); assert_true_with_message( ret !=0 && err != NULL && err->code== EINVAL && *buff_endpoint=='\0', " must be a reported error, bdii is disable"); g_clear_error(&err); gfal_handle_freeG(handle); }
void gfal2_test_gfal_srm_determine_endpoint_full_endpointG() { #if USE_MOCK setup_mock_bdii(); #endif GError* err = NULL; char buff_endpoint[2048]; enum gfal_srm_proto proto; gfal_handle handle = gfal_initG(&err); assert_true_with_message(handle != NULL, " handle is not properly allocated"); if(handle==NULL) return; gfal_srmv2_opt opts; gfal_srm_opt_initG(&opts, handle); int ret =-1; ret = gfal_srm_determine_endpoint(&opts, TEST_SRM_DPM_FULLENDPOINT_PREFIX, buff_endpoint, 2048, &proto, &err); assert_true_with_message( ret ==0 && err == NULL && strings_are_equal(buff_endpoint, TEST_SRM_DPM_FULLENDPOINT_URL), " must be a succesfull endpoint determination %d %ld %s", ret, err, buff_endpoint); gfal_check_GError(&err); ret = gfal_srm_determine_endpoint(&opts, "srm://srm-pps:8443/srm/managerv2?SFN=/castor/cern.ch/grid/dteam/castordev/test-srm-pps_8443-srm2_d0t1-ed6b7013-5329-4f5b", buff_endpoint, 2048, &proto, &err); assert_true_with_message( ret ==0 && err == NULL && strings_are_equal(buff_endpoint, "httpg://srm-pps:8443/srm/managerv2"), " must be a succesfull endpoint determination 2 %d %ld %s", ret, err, buff_endpoint); gfal_check_GError(&err); gfal_handle_freeG(handle); }
static GVarType get_proc(const void *obj, const char *name, GVarData *prop, void *udata) { Quark *q = (Quark *) obj; Grace *grace = grace_from_quark(q); DataColumn col; int column; if (!q) { return GVarNil; } if (strings_are_equal(name, "idstr")) { prop->str = copy_string(NULL, QIDSTR(q)); return GVarStr; } else if (strings_are_equal(name, "active")) { prop->boolval = quark_is_active(q); return GVarBool; } switch (quark_fid_get(q)) { case QFlavorSSD: if (strings_are_equal(name, "nrows")) { prop->num = ssd_get_nrows(q); return GVarNum; } else if (strings_are_equal(name, "ncols")) { prop->num = ssd_get_ncols(q); return GVarNum; } else if ((column = ssd_get_column_by_name(q, name)) >= 0) { prop->arr = ssd_get_darray(q, column); return GVarArr; } else { return GVarNil; } break; case QFlavorSet: if (strings_are_equal(name, "length")) { prop->num = set_get_length(q); return GVarNum; } else if ((col = get_dataset_col_by_name(grace, name)) != DATA_BAD) { prop->arr = set_get_darray(q, col); return GVarArr; } else { return GVarNil; } break; default: return GVarNil; break; } }
static void check_type_read_and_store_info(char *type, char *name, double coordinates_center_x, double coordinates_center_y) { if (strings_are_equal(type, "input")) { create_input_list (type, name, coordinates_center_x, coordinates_center_y); } else if (strings_are_equal(type, "output")) { create_output_list (type, name, coordinates_center_x, coordinates_center_y); } else { //it is a cell create_cell_list (type, name, coordinates_center_x, coordinates_center_y); } }
void gfal2_test_gfal_srm_getTURLS_pipeline_success() { setup_mock_srm(); setup_mock_bdii(); int i1; #if USE_MOCK define_se_endpoints = calloc(sizeof(char*), 4); // set the response of the MDS layer for endpoint for(i1=0;i1 <3; ++i1) define_se_endpoints[i1]= strdup(TEST_SRM_DPM_FULLENDPOINT_URL); define_se_types= calloc(sizeof(char*), 4); char* types[] = { "srm_v1", "srm_v2", "srm_v1"}; for(i1=0;i1 <3; ++i1) define_se_types[i1]= strdup(types[i1]); will_respond(srm_mock_srm_context_init, 0, want_non_null(context), want_string(srm_endpoint, TEST_SRM_DPM_FULLENDPOINT_URL)); defined_get_output = calloc(sizeof(struct srmv2_pinfilestatus),3); defined_get_output[0].turl= strdup(TEST_SRM_TURL_EXAMPLE1); defined_get_output[1].status= ENOENT; defined_get_output[1].explanation = strdup("err msg"); defined_get_output[2].turl = strdup(TEST_SRM_TURL_EXAMPLE1); will_respond(srm_mock_srm_prepare_to_get, 3, want_non_null(context), want_non_null(input), want_non_null(output)); always_return(srm_mock_srm_srmv2_filestatus_delete,0); always_return(srm_mock_srm_srmv2_pinfilestatus_delete,0); #endif GError* tmp_err=NULL; gfal_handle handle = gfal_initG(&tmp_err); assert_true_with_message(handle != NULL, " handle is not properly allocated"); if(handle==NULL) return; gfal_srmv2_opt opts; gfal_srm_opt_initG(&opts, handle); gfal_plugins_instance(handle, NULL); gfal_srm_result* resu=NULL; char* surls[] = {TEST_SRM_VALID_SURL_EXAMPLE1, TEST_SRM_INVALID_SURL_EXAMPLE2, TEST_SRM_VALID_SURL_EXAMPLE1, NULL}; int ret = gfal_srm_getTURLS(&opts, surls, &resu, &tmp_err); assert_true_with_message(ret ==g_strv_length(surls) && resu != NULL && tmp_err == NULL, " must be a successfull request"); gfal_check_GError(&tmp_err); assert_true_with_message(resu[0].err_code == 0 && *(resu[0].err_str)== '\0' && strings_are_equal(resu[0].turl, TEST_SRM_TURL_EXAMPLE1), " must be a valid turl, maybe the turl has changed %d %ld %s",resu[0].err_code, resu[0].err_str, resu[0].turl); assert_true_with_message(resu[1].err_code == ENOENT && *(resu[1].err_str)!= '\0' && *(resu[1].turl) == '\0', " must be a invalid turl 2 "); assert_true_with_message(resu[2].err_code == 0 && *(resu[2].err_str)== '\0' && strings_are_equal(resu[2].turl, TEST_SRM_TURL_EXAMPLE1), " must be a valid turl 3, maybe the turl has changed "); free(resu); gfal_handle_freeG(handle); }
Client<HTTP>::Client( boost::asio::io_service& io_service, http_action ha, const std::string& server, const std::string& port, // examples: "default", "8080", "2345", "http", "ftp", etc. // "default" will become "80" if b_use_ssl is false, or "443" if true const std::string& path, const std::string& header, const std::string& body, // directly placed into request bool b_binary_result, const string& username, const string& password ) : // Call base class ClientBase<HTTP>::ClientBase(io_service, header, b_binary_result) { // Set up the type-specific socket. socket_=std::make_shared<HTTP>(io_service); // Configure the correct default port. string actual_port = port; if (strings_are_equal(actual_port,"default")) { actual_port = "80"; } aresolve(ha, server, actual_port, path, header, body, username, password); }
void assert_string_equal_(const char *file, int line, const char *expression, const char *tried, const char *expected) { (*get_test_reporter()->assert_true)( get_test_reporter(), file, line, strings_are_equal(tried, expected), "[%s] should be [%s] but was [%s]\n", expression, show_null_as_the_string_null(expected), show_null_as_the_string_null(tried)); }
void assert_string_not_equal_(const char *file, int line, const char *tried, const char *expected) { (*get_test_reporter()->assert_true)( get_test_reporter(), file, line, ! strings_are_equal(tried, expected), "[%s] should not match [%s]", show_null_as_the_string_null(tried), show_null_as_the_string_null(expected)); }
datalog_element *datalog_definition::element_by_name(const char *name) { if(name == NULL) return NULL; datalog_element *x = element; while(x != NULL) { if(strings_are_equal(name,x->short_name) == true) return x; x = x->next; } //qDebug() << "Can't find element: " << name << "in definition" << get_msg_number(); return NULL; }
static int set_proc(void *obj, const char *name, GVarType type, GVarData prop, void *udata) { Quark *q = (Quark *) obj; Grace *grace = grace_from_quark(q); DataColumn col; int column; if (!q) { return RETURN_FAILURE; } if (strings_are_equal(name, "idstr") && type == GVarStr) { return quark_idstr_set(q, prop.str); } else if (strings_are_equal(name, "active") && type == GVarBool) { return quark_set_active(q, prop.boolval); } switch (quark_fid_get(q)) { case QFlavorSSD: if ((column = ssd_get_column_by_name(q, name)) >= 0) { return ssd_set_darray(q, column, prop.arr); } else { return RETURN_FAILURE; } break; case QFlavorSet: if ((col = get_dataset_col_by_name(grace, name)) != DATA_BAD) { if (set_set_length(q, prop.arr->size) != RETURN_SUCCESS) { return RETURN_FAILURE; } else { return set_set_darray(q, col, prop.arr); } } else { return RETURN_FAILURE; } break; default: return RETURN_FAILURE; break; } }
void gfal2_test__gfal_convert_full_surl() { int res = -1; char buff[2048]; GError* tmp_err=NULL; res= gfal_get_fullendpointG(TEST_SRM_DPM_FULLENDPOINT_PREFIX, buff, 2048, &tmp_err); assert_true_with_message( res == 0 && strings_are_equal(buff, TEST_SRM_DPM_FULLENDPOINT_URL) && tmp_err==NULL, " must be a successfull endpoint convertion"); g_clear_error(&tmp_err); res= gfal_get_fullendpointG(TEST_SRM_DPM_FULLENDPOINT_PREFIX, buff, 2, &tmp_err); assert_true_with_message( res != 0 && tmp_err!=NULL && tmp_err->code == ENOBUFS, " must be a buffer to small"); g_clear_error(&tmp_err); }
Client<HTTPS>::Client( boost::asio::io_service& io_service, http_action ha, const std::string& server, const std::string& port, const std::string& path, const std::string& header, const std::string& body, bool b_binary_result, const string& username, const string& password, bool verify_certificate, const std::string& cert_file, const std::string& private_key_file, const std::string& verify_file ) : // Call base class ClientBase<HTTPS>::ClientBase(io_service, header, b_binary_result), // Init vars // MDM Have the whole world really gone from ssl2 to tls1? // asio_context_(boost::asio::ssl::context::sslv23) asio_context_(boost::asio::ssl::context::tlsv1) { if(verify_certificate) asio_context_.set_verify_mode(boost::asio::ssl::verify_peer); else asio_context_.set_verify_mode(boost::asio::ssl::verify_none); if(cert_file.size()>0 && private_key_file.size()>0) { asio_context_.use_certificate_chain_file(cert_file); asio_context_.use_private_key_file(private_key_file, boost::asio::ssl::context::pem); } if(verify_file.size()>0) asio_context_.load_verify_file(verify_file); socket_=std::make_shared<HTTPS>(io_service, asio_context_); // Configure the correct default port. string actual_port = port; if (strings_are_equal(actual_port,"default")) { actual_port = "443"; } aresolve(ha, server, actual_port, path, header, body, username, password); }
static obj_t find_symbol(obj_t name) { obj_t p, sym; obj_t sym_name; CHECK(is_string(name), "must be string", name); for (p = all_symbols_list; !is_null(p); p = pair_cdr(p)) { assert(is_pair(p)); sym = pair_car(p); assert(is_symbol(sym)); sym_name = symbol_name(sym); assert(is_string(sym_name)); if (strings_are_equal(sym_name, name)) return sym; } return EMPTY_LIST; }
int save_project(GProject *gp, char *fn) { GrFILE *grf; Quark *project = gproject_get_top(gp); GUI *gui = gui_from_quark(project); int noask_save; static int save_unsupported = FALSE; int retval; if (!project || !fn) { return RETURN_FAILURE; } if (fn && strstr(fn, ".agr")) { errmsg("Cowardly refusing to overwrite an agr file"); return RETURN_FAILURE; } if (!save_unsupported && !yesno("The current format may be unsupported by the final release. Continue?", "Yeah, I'm brave!", NULL, "doc/UsersGuide.html#unsupported_format")) { return RETURN_FAILURE; } save_unsupported = TRUE; noask_save = gui->noask; if (strings_are_equal(gproject_get_docname(gp), fn)) { /* If saving under the same name, don't warn about overwriting */ gui->noask = TRUE; } grf = grfile_openw(fn); if (!grf) { return RETURN_FAILURE; } gui->noask = noask_save; retval = gproject_save(gp, grf); grfile_free(grf); return retval; }
static void save_wisdom(void){ char *final_wisdom; final_wisdom = fftw_export_wisdom_to_string(); if (!initial_wisdom || strings_are_equal(initial_wisdom, final_wisdom) != TRUE) { FILE *wf; wf = gapp_openw(gapp, wisdom_file); if (wf) { fftw_export_wisdom_to_file(wf); gapp_close(wf); } } fftw_free(final_wisdom); if (initial_wisdom) { fftw_free(initial_wisdom); } }
void gfal2_test_gfal_srm_determine_endpoint_not_fullG() { #if USE_MOCK int i1; setup_mock_bdii(); char buff_tmp[2048]; char* p = TEST_SRM_DPM_ENDPOINT_PREFIX+ strlen(GFAL_PREFIX_SRM); g_strlcpy(buff_tmp, p, strchr(p, '/')-p+1); define_se_endpoints = calloc(sizeof(char*), 4); for(i1=0;i1 <3; ++i1) define_se_endpoints[i1]= strdup(TEST_SRM_DPM_FULLENDPOINT_URL); define_se_types= calloc(sizeof(char*), 4); char* types[] = { "srm_v1", "srm_v2", "srm_v1"}; for(i1=0;i1 <3; ++i1) define_se_types[i1]= strdup(types[i1]); #endif GError* err = NULL; char buff_endpoint[2048]; enum gfal_srm_proto proto; gfal_handle handle = gfal_initG(&err); assert_true_with_message(handle != NULL, " handle is not properly allocated"); if(handle==NULL) return; gfal_srmv2_opt opts; gfal_srm_opt_initG(&opts, handle); gfal_plugins_instance(handle, NULL); int ret =-1; ret = gfal_srm_determine_endpoint(&opts, TEST_SRM_DPM_ENDPOINT_PREFIX, buff_endpoint, 2048, &proto, &err); assert_true_with_message( ret ==0 && err == NULL && strings_are_equal(buff_endpoint, TEST_SRM_DPM_FULLENDPOINT_URL), " must be a succesfull endpoint determination %d %ld %s", ret, err, buff_endpoint); gfal_check_GError(&err); ret = gfal_srm_determine_endpoint(&opts, "http://google.com", buff_endpoint, 2048, &proto, &err); assert_true_with_message( ret !=0 && err != NULL, "error must be reported %d %s", ret, ((err)?err->message:"")); g_clear_error(&err); gfal_handle_freeG(handle); }
void gfal2_test_gfal_get_endpoint_and_setype_from_bdiiG(){ GError* err= NULL; int i1; char buff_endpoint[2048]; memset(buff_endpoint, '\0', sizeof(char)*2048); enum gfal_srm_proto proto; #if USE_MOCK setup_mock_bdii(); char buff_tmp[2048]; char* p = TEST_SRM_DPM_ENDPOINT_PREFIX+ strlen(GFAL_PREFIX_SRM); g_strlcpy(buff_tmp, p, strchr(p, '/')-p+1); define_se_endpoints = calloc(sizeof(char*), 4); for(i1=0;i1 <3; ++i1) define_se_endpoints[i1]= strdup(TEST_SRM_DPM_FULLENDPOINT_URL); define_se_types= calloc(sizeof(char*), 4); char* types[] = { "srm_v1", "srm_v2", "srm_v1"}; for(i1=0;i1 <3; ++i1) define_se_types[i1]= strdup(types[i1]); #endif gfal_handle handle = gfal_initG(&err); assert_true_with_message(handle != NULL, " handle is not properly allocated"); if(handle==NULL) return; gfal_srmv2_opt opts; gfal_srm_opt_initG(&opts, handle); char* surl = TEST_SRM_DPM_ENDPOINT_PREFIX; int ret = gfal_get_endpoint_and_setype_from_bdiiG(&opts, surl, buff_endpoint, 2048, &proto, &err); assert_true_with_message( ret ==0 && err== NULL && strings_are_equal(buff_endpoint, TEST_SRM_DPM_FULLENDPOINT_URL) && proto== PROTO_SRMv2, " must be a valid endpoint resolution"); gfal_check_GError(&err); memset(buff_endpoint, '\0', sizeof(char)*2048); ret = gfal_get_endpoint_and_setype_from_bdiiG(&opts, "srm://lxb540dfshhhh9.cern.ch:8446/test/invalid", buff_endpoint, 2048, &proto, &err); assert_true_with_message(ret != 0 && err != NULL && err->code==ENXIO && *buff_endpoint== '\0', " must fail, invalid point"); g_clear_error(&err); gfal_handle_freeG(handle); }
void parse_size_file(char *type, double *width, double *height) { FILE *sizes; char buffer[MAX_LINE_CHARS] = {0, }; char *tmp; char delimeter[4] = " \t\n"; sizes = fopen("NangateLibrarySizes.txt", "r"); if (sizes == NULL) { printf("Didn't open Sizes file.\n"); } while (fgets(buffer, MAX_LINE_CHARS, sizes) != NULL) { tmp = strtok(buffer, delimeter); if (tmp == NULL) continue; if(strings_are_equal(tmp, type)) { tmp = strtok(NULL, delimeter); *width = (double) atof(tmp); tmp = strtok(NULL, delimeter); *height = (double) atof(tmp); } } }
void request_parser::parse_content(request& req) { if (req.content.empty()) { return; } std::string standard_type = "application/x-www-form-urlencoded"; std::string multipart_type = "multipart/form-data"; std::string content_type = req.header("Content-Type"); if (content_type.empty() || strings_are_equal(content_type, standard_type, standard_type.size())) { std::string name, value; std::string::size_type pos; std::string::size_type old_pos = 0; while (true) { pos = req.content.find_first_of("&=", old_pos); if (pos == std::string::npos) { break; } if (req.content.at(pos) == '&') { const char* c_str_ = req.content.c_str() + old_pos; while (*c_str_ == '&') { ++c_str_; ++old_pos; } if (old_pos >= pos) { old_pos = ++pos; continue; } name = percent_decode(req.content.substr(old_pos, pos - old_pos)); req.params.push_back(name_value(name, std::string())); old_pos = ++pos; continue; } name = percent_decode(req.content.substr(old_pos, pos - old_pos)); old_pos = ++pos; pos = req.content.find_first_of(";&", old_pos); value = percent_decode(req.content.substr(old_pos, pos - old_pos)); req.params.push_back(name_value(name, value)); if (pos == std::string::npos) { break; } old_pos = ++pos; } } else if (strings_are_equal(multipart_type, content_type, multipart_type.size())) { std::string b_type = "boundary="; std::string::size_type pos = content_type.find(b_type); std::string sep1 = content_type.substr(pos + b_type.size()); if (sep1.find(";") != std::string::npos) { sep1 = sep1.substr(0, sep1.find(";")); } sep1.append("\r\n"); sep1.insert(0, "--"); std::string sep2 = content_type.substr(pos + b_type.size()); if (sep2.find(";") != std::string::npos) { sep2 = sep2.substr(0, sep2.find(";")); } sep2.append("--\r\n"); sep2.insert(0, "--"); std::string::size_type start = req.content.find(sep1); std::string::size_type sep_size = sep1.size(); std::string::size_type old_pos = start + sep_size; while (true) { pos = req.content.find(sep1, old_pos); if (pos == std::string::npos) { break; } parse_multipart_content(req, req.content.substr(old_pos, pos - old_pos)); old_pos = pos + sep_size; } pos = req.content.find(sep2, old_pos); if (pos != std::string::npos) { parse_multipart_content(req, req.content.substr(old_pos, pos - old_pos)); } } }
void wall_clock_proc(void) { msg_buf* message = (msg_buf*)request_memory_block(); Node* msg_node = (Node*)request_memory_block(); message->mtype = KCD_REG; copy_string("%W", message->mtext); //send register cmd to KCD msg_node->sender_id = PID_CLOCK; msg_node->receiving_id = PID_KCD; msg_node->data = message; send_message_node(msg_node); while (1){ int neg_1 = -1; msg_buf* message = (msg_buf*) receive_message(&neg_1); if (message == NULL) { continue; } if (strings_are_equal(message->mtext,"D")) { // HH:MM:SS int seconds = (int) (g_clock / 1000) % 60 ; int minutes = (int) ((g_clock / (1000*60)) % 60); int hours = (int) ((g_clock / (1000*60*60)) % 24); msg_buf* mtime; Node* msg_node; // Generate HH:MM:SS char array char output[11]; output[0] = '0' + hours/10; output[1] = '0' + hours%10; output[2] = ':'; output[3] = '0' + minutes/10; output[4] = '0' + minutes%10; output[5] = ':'; output[6] = '0' + seconds/10; output[7] = '0' + seconds%10; output[8] = '\n'; output[9] = '\r'; output[10] = '\0'; // Send message to display the clock mtime = (msg_buf*)request_memory_block(); mtime->mtype = CRT_DISPLAY; copy_string(output, mtime->mtext); msg_node = (Node*)request_memory_block(); msg_node->sender_id = PID_CLOCK; msg_node->receiving_id = PID_CRT; msg_node->data = mtime; send_message_node(msg_node); } else if (message->mtext[2] == 'T') { // Terminate Displaying of Clock display_clock = false; } else if (message->mtext[2] == 'R') { // Reset Clock g_clock = 0; display_clock = true; } else if (message->mtext[2] == 'S') { // Input: %WS HH:MM:SS [12] int hour; int minute; int seconds; if (message->mtext[6] != ':' || message->mtext[9] != ':') { msg_buf* minv = (msg_buf*)request_memory_block(); Node* msg_node = (Node*)request_memory_block(); minv->mtype = CRT_DISPLAY; copy_string("Invalid Time for wallclock proc\n\r", minv->mtext); msg_node->sender_id = PID_CLOCK; msg_node->receiving_id = PID_CRT; msg_node->data = minv; send_message_node(msg_node); } else { // Get Hours hour = message->mtext[4] - '0'; hour *= 10; hour += message->mtext[5] - '0'; // Get Minutes minute = message->mtext[7] - '0'; minute *= 10; minute += message->mtext[8] - '0'; // Get Seconds seconds = message->mtext[10] - '0'; seconds *= 10; seconds += message->mtext[11] - '0'; // Convert HH:MM:SS to ms for g_clock g_clock = hour*(1000*60*60) + minute*(1000*60) + seconds*(1000); // Enable Displaying of Clock display_clock = true; } } release_memory_block(message); } }
static int compare_want_string(Constraint *constraint, intptr_t comparison) { return strings_are_equal((const char *)constraint->expected, (const char *)comparison); }
static int leaveCB(TableEvent *event) { SSDataUI *ui = (SSDataUI *) event->anydata; int nrows = ssd_get_nrows(ui->q); int ncols = ssd_get_ncols(ui->q); int format; double value; int changed = FALSE; GraceApp *gapp = gapp_from_quark(ui->q); if (event->row < 0 || event->col < 0 || event->col > ncols) { return TRUE; } if (event->row >= nrows && !string_is_empty(event->value)) { if (ssd_set_nrows(ui->q, event->row + 1) == RETURN_SUCCESS) { changed = TRUE; } } if (event->col == ncols && !string_is_empty(event->value)) { if (parse_date_or_number(get_parent_project(ui->q), event->value, FALSE, get_date_hint(gapp), &value) == RETURN_SUCCESS) { format = FFORMAT_NUMBER; } else { format = FFORMAT_STRING; } if (ssd_add_col(ui->q, format)) { ncols++; changed = TRUE; } } if (event->col < ncols) { char *old_value = get_cell_content(ui, event->row, event->col, &format); if (!strings_are_equal(old_value, event->value)) { switch (format) { case FFORMAT_STRING: if (ssd_set_string(ui->q, event->row, event->col, event->value) == RETURN_SUCCESS) { quark_dirtystate_set(ui->q, TRUE); changed = TRUE; } break; default: if (graal_eval_expr(grace_get_graal(gapp->grace), event->value, &value, gproject_get_top(gapp->gp)) == RETURN_SUCCESS) { unsigned int prec; char buf[32]; double val; prec = project_get_prec(get_parent_project(ui->q)); sprintf(buf, "%.*g", prec, value); if (parse_date_or_number(get_parent_project(ui->q), buf, FALSE, get_date_hint(gapp), &val) == RETURN_SUCCESS) { if (ssd_set_value(ui->q, event->row, event->col, val) == RETURN_SUCCESS) { quark_dirtystate_set(ui->q, TRUE); changed = TRUE; } } } else { errmsg("Can't parse input value"); return FALSE; } break; } } } if (changed) { snapshot_and_update(gapp->gp, FALSE); } return TRUE; }
static bool actual_value_not_necessary_for(Constraint *constraint, const char *actual_string, const char *actual_value_string) { (void)constraint; // UNUSED! return strings_are_equal(actual_string, actual_value_string) || strings_are_equal(actual_string, "true") || strings_are_equal(actual_string, "false"); }
static bool compare_want_string(Constraint *constraint, intptr_t actual) { return strings_are_equal((const char *)constraint->expected_value, (const char *)actual); }