void accept_dlg_lang(HWND wnd,DWORD id)
{
RETSTR *crs,*crr;
char p_str[64];
DWORD afc,afc2,ofs,sz,d;
AF *af;
char *buf;
buf = lang_file[2].str;
sz = lang_file[2].dx;
afc=ofs=0;
sprintf(p_str,"[%i=%%*]%%*{%%*}",id);
af= make_af(p_str,0,&afc);
crs=parse_string(buf,sz,af,afc,1);
if(!crs)
return;
free_af(af,afc);
SetWindowText(wnd,crs[1].str);
af = make_af("(%*)%*=%*\r",0,&afc2);
ofs=0;
while((crr=parse_string(crs[5].str+ofs,0/*crs[5].dx*/,af,afc2,1)))
{
d = StrToInt(crr[1].str);
SetWindowText(GetDlgItem(wnd,d),crr[5].str);
ofs+=crr[6].x+crr[6].dx;
free_crs(crr,afc2);
}
free_crs(crs,afc);
free_af(af,afc2);
}
void parse_msgs(char *buf,DWORD sz)
{
RETSTR *crs;
DWORD afc,id,ofs;
AF *af;
id=afc=ofs=0;
af= make_af("{{%*}}",0,&afc);
free(msgs);
msgs=NULL;
msgs_cnt=0;
while( (crs=parse_string(buf+ofs,0,af,afc,1)) )
{
msgs = (DWORD *)realloc(msgs,(id+2)*sizeof(DWORD));
msgs[id++]= (DWORD)crs[1].str;
msgs[id]= 0;
crs[1].str = NULL;
msgs_cnt++;
ofs+=crs[2].x+crs[2].dx;
free_crs(crs,afc);
}
free_af(af,afc);
}
void free_lang()
{
free_crs(lang_file,lf_afc);
for(int i=0;i<msgs_cnt;i++)
free((void *)msgs[i]);
free(msgs);
msgs=NULL;
lang_file=NULL;
msgs_cnt=0;
}
int main()
{
/*FILE *f;
char fn[] = "data.txt";
f = fopen(fn, "w");
if(f == NULL)
{
printf("Error: FILE!\n");
exit(1);
}*/
//TESTING
//TEST - STANDARD COPY, COMPRESS, DECOMPRESS, MULTIPLICATION
Matrix* test_mtx_1 = init_matrix(1000, 1000);
f2(test_mtx_1, 1, 1, 2);
Matrix* test_mtx_2 = copy_matrix(test_mtx_1);
test(assert_matrix(test_mtx_1, test_mtx_2), "Copy matrix");
CRS* test_crs_1 = cp_crs(test_mtx_1);
CCS* test_ccs_1 = cp_ccs(test_mtx_2);
Matrix* test_ucp_mtx_1 = uncp_crs(test_crs_1);
Matrix* test_ucp_mtx_2 = uncp_ccs(test_ccs_1);
test(assert_matrix(test_ucp_mtx_1, test_mtx_1), "Decompress crs");
test(assert_matrix(test_ucp_mtx_2, test_mtx_2), "Decompress ccs");
test(assert_matrix(test_ucp_mtx_1, test_ucp_mtx_2), "Decompress matrix");
Vector* standard_vector = gen_vector(1000, 0.1, 1);
Vector* crs_product = mtp_crs(test_crs_1, standard_vector);
Vector* ccs_product = mtp_ccs(test_ccs_1, standard_vector);
test(assert_vector(crs_product, ccs_product), "CCS and CRS product");
//TEST - CLEAN
free_matrix(test_mtx_1);
free_matrix(test_mtx_2);
free_ccs(test_ccs_1);
free_crs(test_crs_1);
free_vector(standard_vector);
free_vector(crs_product);
free_vector(ccs_product);
free_matrix(test_ucp_mtx_1);
free_matrix(test_ucp_mtx_2);
//TESTING
//TEST - CRS PARALLEL PRODUCT
Matrix* test_mtx = init_matrix(100, 100);
f2(test_mtx, 1, 1, 2);
CRS* standard_test_crs = cp_crs(test_mtx);
Vector* vector = gen_vector(100, 0.1, 1);
free_matrix(test_mtx);
Vector* standard_product = mtp_crs(standard_test_crs, vector);
Vector* openmp_product = openmp_mtp_crs(standard_test_crs, vector);
test(assert_vector(standard_product, openmp_product), "CRS openmp product validation");
free_vector(openmp_product);
Vector* pthread_product = pthread_mtp_crs(standard_test_crs, vector);
test(assert_vector(standard_product, pthread_product), "CRS pthread product validation");
free_vector(pthread_product);
//TEST - CLEAN
//free_matrix(test_mtx);
free_crs(standard_test_crs);
free_vector(vector);
free_vector(standard_product);
/*
//_________________________________________________________________________________
//TEST - SPEED
Matrix* mtx_speed = init_matrix(10,10);
f2(mtx_speed,1,1,2);
CRS* crs_speed = cp_crs(mtx_speed);
CCS* ccs_speed = cp_ccs(mtx_speed);
Vector* vector_speed = gen_vector(10, 0.1, 1);
printf("\nStandard ccs product\n");
init_stoper();
Vector* mtp_ccs_product = mtp_ccs(ccs_speed, vector_speed);
print_stoper();
printf("\nStandard crs product\n");
init_stoper();
Vector* mtp_crs_product = mtp_crs(crs_speed, vector_speed);
print_stoper();
//TEST - PRODUCT VALIDATION
test(assert_vector(mtp_ccs_product, mtp_crs_product), "ccs and crs product");
//TEST - CLEAN
free_crs(crs_speed);
free_ccs(ccs_speed);
//TEST - OPENMP PRODUCT
CRS* openmp_crs_speed = cp_crs(mtx_speed);
printf("\nopenmp crs product\n");
init_stoper();
Vector* openmp_mtp_crs_product = openmp_mtp_crs(openmp_crs_speed, vector_speed);
print_stoper();
//TEST - OPENMP PRODUCT VALIDATION
test(assert_vector(openmp_mtp_crs_product, mtp_crs_product), "openmp product validation");
//TEST - OPENMP CLEAN
free_crs(openmp_crs_speed);
free_vector(openmp_mtp_crs_product);
//TEST - PTHREAD PRODUCT
CRS* pthread_crs_speed = cp_crs(mtx_speed);
printf("\npthread crs product\n");
init_stoper();
Vector* pthread_mtp_crs_product = pthread_mtp_crs(pthread_crs_speed, vector_speed);
print_stoper();
//TEST - PTHREAD PRODUCT VALIDATION
test(assert_vector(pthread_mtp_crs_product, mtp_crs_product), "pthread product validation");
//TEST PTHREAD CLEAN
free_crs(pthread_crs_speed);
free_vector(pthread_mtp_crs_product);
//TEST - MPI PRODUCT
CRS* mpi_crs_speed = copy_crs(crs_speed);
printf("\nmpi crs product\n");
init_stoper();
Vector* mpi_mtp_crs_product = mpi_mtp_crs(mpi_crs_speed, vector_speed);
print_stoper();
//TEST - MPI PRODUCT VALIDATION
test(assert_vector(mpi_mtp_crs_product, mtp_crs_product), "mpi product validation");
//TEST - MPI CLEAN
free_crs(mpi_crs_speed);
free_vector(mpi_mtp_crs_product);
*/
return 0;
}
