|
ocssw
1.0
|
00001 /* 00002 * $Id: epr_msph.c,v 1.1.1.1 2004-10-28 19:22:23 norman Exp $ 00003 * 00004 * Copyright (C) 2002 by Brockmann Consult (info@brockmann-consult.de) 00005 * 00006 * This program is free software; you can redistribute it and/or modify it 00007 * under the terms of the GNU General Public License as published by the 00008 * Free Software Foundation. This program is distributed in the hope it will 00009 * be useful, but WITHOUT ANY WARRANTY; without even the implied warranty 00010 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 00011 * See the GNU General Public License for more details. 00012 * 00013 * You should have received a copy of the GNU General Public License 00014 * along with this program; if not, write to the Free Software 00015 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 00016 */ 00017 00018 #include <assert.h> 00019 #include <errno.h> 00020 #include <stdio.h> 00021 #include <stdlib.h> 00022 #include <string.h> 00023 00024 #include "epr_api.h" 00025 #include "epr_core.h" 00026 #include "epr_string.h" 00027 #include "epr_ptrarray.h" 00028 #include "epr_swap.h" 00029 #include "epr_field.h" 00030 #include "epr_record.h" 00031 #include "epr_param.h" 00032 #include "epr_dsd.h" 00033 #include "epr_msph.h" 00034 #include "epr_band.h" 00035 #include "epr_bitmask.h" 00036 00037 00047 EPR_SRecord* epr_read_mph(EPR_SProductId* product_id) 00048 { 00049 EPR_SRecord* record = NULL; 00050 char* code_block; 00051 int numread; 00052 00053 epr_clear_err(); 00054 00055 code_block = epr_create_string(EPR_MPH_SIZE); 00056 if (code_block == NULL) 00057 { 00058 epr_set_err(e_err_out_of_memory, 00059 "epr_read_mph: out of memory"); 00060 return NULL; 00061 } 00062 rewind(product_id->istream); 00063 numread = fread(code_block, 1, EPR_MPH_SIZE, product_id->istream); 00064 00065 if (numread != EPR_MPH_SIZE) 00066 { 00067 epr_set_err(e_err_file_read_error, 00068 "epr_read_mph: wrong reading MPH from product data file"); 00069 return NULL; 00070 } 00071 record = epr_parse_header("mph", code_block); 00072 if (record == NULL) 00073 { 00074 epr_set_err(e_err_invalid_record, 00075 "epr_read_mph: can not recognize the correct MPH from product data file"); 00076 } else { 00077 epr_add_ptr_array_elem(product_id->record_info_cache, record->info); 00078 } 00079 00080 epr_free_string(code_block); 00081 return record; 00082 } 00083 00092 EPR_SRecord* epr_read_sph(EPR_SProductId* product_id) 00093 { 00094 EPR_SRecord* sph_record = NULL; 00095 const EPR_SField* field; 00096 00097 char* code_block; 00098 int numread; 00099 epr_uint sph_length = 0; 00100 epr_uint sph_without_dsd_length = 0; 00101 epr_uint dsd_number = 0; 00102 00103 epr_clear_err(); 00104 00105 if (product_id->mph_record == NULL) { 00106 product_id->mph_record = epr_read_mph(product_id); 00107 if (product_id->mph_record == NULL) { 00108 epr_set_err(e_err_file_read_error, "epr_read_sph: wrong MPH"); 00109 return NULL; 00110 } 00111 } 00112 00113 field = epr_get_field(product_id->mph_record, "SPH_SIZE"); 00114 sph_length = ((epr_uint*) field->elems)[0]; 00115 if (sph_length == 0) { 00116 epr_set_err(e_err_invalid_value, 00117 "epr_read_sph: wrong MPH: SPH_SIZE must be > 0"); 00118 return NULL; 00119 } 00120 field = epr_get_field(product_id->mph_record, "NUM_DSD"); 00121 dsd_number = ((epr_uint*) field->elems)[0]; 00122 if (dsd_number == 0) { 00123 epr_set_err(e_err_invalid_value, 00124 "epr_read_sph: wrong MPH: NUM_DSD must be > 0"); 00125 return NULL; 00126 } 00127 00128 epr_api.epr_head_size = sph_length + EPR_MPH_SIZE; 00129 if (fseek(product_id->istream, EPR_MPH_SIZE, SEEK_SET) != 0) { 00130 epr_set_err(e_err_file_access_denied, 00131 "epr_read_sph: file seek failed"); 00132 return NULL; 00133 } 00134 00135 sph_without_dsd_length = sph_length - dsd_number * EPR_DSD_SIZE; 00136 00137 code_block = epr_create_string(sph_without_dsd_length); 00138 numread = fread(code_block, 1, sph_without_dsd_length, product_id->istream); 00139 if ((epr_uint)numread != sph_without_dsd_length) { 00140 epr_set_err(e_err_file_read_error, 00141 "epr_read_sph: wrong reading SPH from product data file"); 00142 return NULL; 00143 } 00144 00145 sph_record = epr_parse_header("sph", code_block); 00146 if (sph_record == NULL) { 00147 epr_set_err(e_err_invalid_record, 00148 "epr_read_sph: can not recognize the correct SPH from product data file"); 00149 } else { 00150 epr_add_ptr_array_elem(product_id->record_info_cache, sph_record->info); 00151 } 00152 00153 epr_free_string(code_block); 00154 return sph_record; 00155 } 00156 00157 void epr_store_header(const char* header_name, const char* ascii_source) { 00158 FILE* os; 00159 char fname[1024]; 00160 sprintf(fname, "%s.txt", header_name); 00161 os=fopen(fname, "w"); 00162 fprintf(os,"%s", ascii_source); 00163 fclose(os); 00164 } 00165 00166 00174 EPR_SRecord* epr_parse_header(const char* header_name, const char* ascii_source) 00175 { 00176 EPR_SRecordInfo* record_info; 00177 EPR_SPtrArray* field_infos = NULL; 00178 EPR_SFieldInfo* field_info; 00179 EPR_SPtrArray* header_values = NULL; 00180 EPR_SRecord* record = NULL; 00181 EPR_EDataTypeId tp; 00182 char * code_block; 00183 char seps[] = EPR_HEADER_SEPARATOR_ARRAY; 00184 char * token_name; 00185 char * token_value; 00186 char * token_unit; 00187 char * h_name; 00188 int pos = 0; 00189 int pos_ascii = 0; 00190 epr_uint num_bytes = 0; 00191 epr_uint num_elems = 0; 00192 00193 epr_clear_err(); 00194 00195 /* uncomment for debugging purpose */ 00196 /* epr_store_header(header_name, ascii_source); */ 00197 00198 header_values = epr_create_ptr_array(16); 00199 field_infos = epr_create_ptr_array(16); 00200 h_name = epr_clone_string(header_name); 00201 00202 while ((code_block = epr_str_tok(ascii_source, "\n", &pos_ascii)) != NULL) { 00203 /*if EMPTY code_block*/ 00204 if ((strlen(code_block) > 0) && (code_block[0] == ' ')) { 00205 /* epr_log(e_log_info, "code_block is empty"); */ 00206 if (code_block != NULL) { 00207 epr_free_string(code_block); 00208 code_block = NULL; 00209 } 00210 continue; 00211 } 00212 /*if '=' separator*/ 00213 pos = 0; 00214 token_name = epr_str_tok(code_block, seps, &pos); 00215 if (pos == 1) { 00216 epr_set_err(e_err_invalid_keyword_name, 00217 "epr_parse_header: invalid ascii header: keyword is empty"); 00218 epr_free_string(token_name); 00219 if (code_block != NULL) { 00220 epr_free_string(code_block); 00221 code_block = NULL; 00222 } 00223 continue; 00224 } 00225 if (pos == (int)strlen(code_block) + 1) { 00226 epr_set_err(e_err_invalid_keyword_name, 00227 "epr_parse_header: invalid ascii header: keyword not found"); 00228 epr_free_string(token_name); 00229 if (code_block != NULL) { 00230 epr_free_string(code_block); 00231 code_block = NULL; 00232 } 00233 continue; 00234 } 00235 /*if STRING value*/ 00236 if (code_block[pos] == '\"') { 00237 pos ++; 00238 /* 00239 Note that strings always are considered as one single element, 00240 so we get the total number of characters from tot_size. 00241 Addidionally we reserve an extra character for the trailing zero (terminator), 00242 */ 00243 token_value = epr_strip_string_r(epr_str_tok(code_block, "\"", &pos)); 00244 token_unit = NULL; 00245 tp = e_tid_string; 00246 num_bytes = (epr_uint)strlen(token_value); 00247 num_elems = 1; 00248 epr_add_ptr_array_elem(header_values, token_value); 00249 } else { 00250 token_value = epr_str_tok(code_block, seps, &pos); 00251 if (token_value == NULL) { 00252 epr_set_err(e_err_invalid_value, 00253 "epr_parse_header: invalid ascii header: value not found"); 00254 token_value = epr_clone_string(""); 00255 token_unit = NULL; 00256 tp = e_tid_uchar; 00257 num_bytes = 0; 00258 num_elems = 1; 00259 epr_add_ptr_array_elem(header_values, token_value); 00260 } else { 00261 /*if FLOAT-DOUBLE value*/ 00262 if (strchr(token_value, '.') != NULL 00263 || strchr(token_value, 'e') != NULL 00264 || strchr(token_value, 'E') != NULL) 00265 { 00266 epr_parse_double_token(header_values, token_value, &num_elems, &num_bytes, &tp); 00267 token_unit = epr_str_tok(code_block, seps, &pos); 00268 00269 epr_free_string(token_value); 00270 token_value = NULL; 00271 00272 /*if INTEGER_LONG value*/ 00273 } else if ((strlen(token_value) > 1)) { 00274 00275 epr_parse_int_token(header_values, token_value, &num_elems, &num_bytes, &tp); 00276 00277 epr_free_string(token_value); 00278 token_value = NULL; 00279 00280 token_unit = epr_str_tok(code_block, seps, &pos); 00281 } else { 00282 /*if CHAR value*/ 00283 if (strlen(token_value) > 1) { 00284 epr_set_err(e_err_invalid_value, 00285 "epr_parse_header: invalid ascii header: illegal value"); 00286 token_value = epr_clone_string(""); 00287 token_unit = NULL; 00288 tp = e_tid_uchar; 00289 num_bytes = 0; 00290 num_elems = 1; 00291 epr_add_ptr_array_elem(header_values, token_value); 00292 epr_free_string(token_name); 00293 if (code_block != NULL) { 00294 epr_free_string(code_block); 00295 code_block = NULL; 00296 } 00297 continue; 00298 } else { 00299 token_unit = NULL; 00300 tp = e_tid_uchar; 00301 num_bytes = (epr_uint)strlen(token_value); 00302 num_elems = 1; 00303 epr_add_ptr_array_elem(header_values, token_value); 00304 } 00305 } 00306 } 00307 } 00308 field_info = epr_create_field_info(tp, h_name, token_name, num_elems, num_bytes, 1, token_unit); 00309 epr_add_ptr_array_elem(field_infos, field_info); 00310 epr_free_string(token_name); 00311 epr_free_string(token_unit); 00312 epr_free_string(code_block); 00313 } 00314 00315 if (field_infos->length > 0) { 00316 record_info = epr_create_record_info(h_name, field_infos); 00317 record = epr_create_record_from_info(record_info); 00318 epr_set_header_field_values(record, header_values); 00319 } 00320 00321 epr_free_char_ptr_array(header_values); 00322 00323 epr_free_string(h_name); 00324 00325 return record; 00326 } 00327 00328 00329 void epr_parse_string_token(EPR_SPtrArray* header_values, char* token_value, epr_uint* num_elems, epr_uint* num_bytes, EPR_EDataTypeId* tp) 00330 { 00331 char exceptions[] = EPR_HEADER_EXCEPTIONS_ARRAY; 00332 char * token_value_o; 00333 char * tmp; 00334 epr_uint pos_value = 0; 00335 int cyc = 0; 00336 00337 pos_value = 0; 00338 *num_elems = 0; 00339 while ((tmp = epr_str_tok_tok(token_value + 1, "+-", exceptions, &pos_value)) != NULL) { 00340 cyc ++; 00341 token_value_o = epr_create_string(strlen(tmp) + 1); 00342 if (strlen(tmp) == strlen(token_value) - 1) { 00343 token_value_o[0] = token_value[0]; 00344 } else if (pos_value < (epr_uint)strlen(token_value) - 1) { 00345 token_value_o[0] = token_value[pos_value - strlen(tmp) - 1]; 00346 } else { 00347 token_value_o[0] = token_value[pos_value - strlen(tmp)]; 00348 } 00349 strcat(token_value_o, tmp); 00350 epr_add_ptr_array_elem(header_values, token_value_o); 00351 epr_free_string(tmp); 00352 } 00353 *num_bytes = sizeof(double); 00354 *tp = e_tid_double; 00355 *num_elems = cyc; 00356 } 00357 00358 void epr_parse_double_token(EPR_SPtrArray* header_values, char* token_value, epr_uint* num_elems, epr_uint* num_bytes, EPR_EDataTypeId* tp) 00359 { 00360 char exceptions[] = EPR_HEADER_EXCEPTIONS_ARRAY; 00361 char * token_value_o; 00362 char * tmp; 00363 epr_uint pos_value = 0; 00364 int cyc = 0; 00365 00366 pos_value = 0; 00367 *num_elems = 0; 00368 while ((tmp = epr_str_tok_tok(token_value + 1, "+-", exceptions, &pos_value)) != NULL) { 00369 cyc ++; 00370 token_value_o = epr_create_string(strlen(tmp) + 1); 00371 if (strlen(tmp) == strlen(token_value) - 1) { 00372 token_value_o[0] = token_value[0]; 00373 } else if (pos_value < (epr_uint)strlen(token_value) - 1) { 00374 token_value_o[0] = token_value[pos_value - strlen(tmp) - 1]; 00375 } else { 00376 token_value_o[0] = token_value[pos_value - strlen(tmp)]; 00377 } 00378 strcat(token_value_o, tmp); 00379 epr_add_ptr_array_elem(header_values, token_value_o); 00380 epr_free_string(tmp); 00381 } 00382 *num_bytes = sizeof(double); 00383 *tp = e_tid_double; 00384 *num_elems = cyc; 00385 } 00386 00387 00388 void epr_parse_int_token(EPR_SPtrArray* header_values, char* token_value, epr_uint* num_elems, epr_uint* num_bytes, EPR_EDataTypeId* tp) 00389 { 00390 char * token_value_o; 00391 char * tmp; 00392 char * tmp_v; 00393 char * stopstring; 00394 int pos_value = 0; 00395 epr_uint dlina; 00396 epr_uint i; 00397 char value_buffer[32]; 00398 int lmp; 00399 epr_uint ulmp; 00400 int flag_int = 0; 00401 //int flag_negative = 0; 00402 int cyc = 0; 00403 00404 pos_value = 0; 00405 *num_elems = 0; 00406 flag_int = 0; 00407 //flag_negative = 0; 00408 00409 if (strchr(token_value, '-') != NULL) { 00410 flag_int = 1; 00411 *num_bytes = sizeof(int); 00412 *tp = e_tid_int; 00413 } else { 00414 *num_bytes = sizeof(epr_uint); 00415 *tp = e_tid_uint; 00416 } 00417 00418 while ((tmp = epr_str_tok(token_value + 1, "+-", &pos_value)) != NULL) { 00419 if (epr_if_no_letters(tmp) == 0) { 00420 epr_set_err(e_err_invalid_value, 00421 "epr_parse_header: invalid ascii header: illegal value"); 00422 cyc ++; 00423 tmp = epr_clone_string("-999999"); 00424 *num_bytes = sizeof(int); 00425 *tp = e_tid_int; 00426 epr_add_ptr_array_elem(header_values, tmp); 00427 } else { 00428 cyc ++; 00429 token_value_o = epr_create_string(strlen(tmp) + 1); 00430 if (strlen(tmp) == strlen(token_value) - 1) { 00431 token_value_o[0] = token_value[0]; 00432 } else if (pos_value < (int)strlen(token_value) - 1) { 00433 token_value_o[0] = token_value[pos_value - strlen(tmp) - 1]; 00434 } else if (strlen(tmp) == 1) { 00435 if (cyc == 1) 00436 token_value_o[0] = token_value[pos_value]; 00437 else 00438 token_value_o[0] = token_value[pos_value - 1]; 00439 } else { 00440 token_value_o[0] = token_value[pos_value - strlen(tmp)]; 00441 } 00442 strcat(token_value_o, tmp); 00443 dlina = (epr_uint)strlen(token_value_o); 00444 tmp_v = epr_create_string(dlina); 00445 /*if int*/ 00446 if (flag_int == 1) { 00447 lmp = strtol(token_value_o, &stopstring, 10); 00448 if (lmp != 0) { 00449 tmp_v[0] = token_value_o[0]; 00450 for (i = 1; i < dlina; i ++) if (token_value_o[i] != '0') break; 00451 if (token_value_o[0] == '+') strncpy(tmp_v + 0, token_value_o + i, dlina - i); 00452 if (token_value_o[0] == '-') strncpy(tmp_v + 1, token_value_o + i, dlina - i); 00453 sprintf(value_buffer, "%d", lmp); 00454 /*if int value too large*/ 00455 if (strcmp(tmp_v, value_buffer) != 0) 00456 epr_log(e_log_warning, "product header: int integer value out of range"); 00457 } 00458 } else if (flag_int == 0) { 00459 ulmp = strtoul(token_value_o, &stopstring, 10); 00460 if (ulmp != 0UL) { 00461 tmp_v[0] = token_value_o[0]; 00462 for (i = 1; i < dlina; i ++) if (token_value_o[i] != '0') break; 00463 strncpy(tmp_v, token_value_o + i, dlina - i); 00464 sprintf(value_buffer, "%u", ulmp); 00465 /*if epr_uint value too large*/ 00466 if (strcmp(tmp_v, value_buffer) != 0) 00467 epr_log(e_log_warning, "product header: unsigned int integer value out of range"); 00468 } 00469 } 00470 epr_free_string(tmp_v); 00471 epr_add_ptr_array_elem(header_values, token_value_o); 00472 epr_free_string(tmp); 00473 } 00474 } 00475 *num_elems = cyc; 00476 } 00477 00478 00479 00487 void epr_set_header_field_values(EPR_SRecord* record, EPR_SPtrArray* header_values) 00488 { 00489 EPR_SFieldInfo* field_info; 00490 EPR_SField* field; 00491 epr_uint ptr_index = 0; 00492 epr_uint field_index; 00493 epr_uint field_info_index; 00494 char * tmp; 00495 char * stopstring; 00496 00497 assert(header_values != NULL); 00498 00499 for (field_index = 0; field_index < record->num_fields; field_index++) { 00500 field = record->fields[field_index]; 00501 field_info = (EPR_SFieldInfo*)epr_get_ptr_array_elem_at(record->info->field_infos, field_index); 00502 00503 for (field_info_index = 0; field_info_index < field->info->num_elems; field_info_index++) { 00504 tmp = (char*)epr_get_ptr_array_elem_at(header_values, ptr_index); 00505 switch (field_info->data_type_id) { 00506 case e_tid_uchar: 00507 *(((epr_uchar*)field->elems) + field_info_index) = (epr_uchar) tmp[field_info_index]; 00508 break; 00509 case e_tid_int: 00510 *(((int*)field->elems) + field_info_index) = strtol(tmp, &stopstring, 10); 00511 break; 00512 case e_tid_uint: 00513 *(((epr_uint*)field->elems) + field_info_index) = strtoul(tmp, &stopstring, 10); 00514 break; 00515 case e_tid_string:; 00516 /*epr_assign_string(&(char*)field->elems, tmp);*/ 00517 strncpy((char*)field->elems, tmp, field->info->tot_size); 00518 break; 00519 case e_tid_double: 00520 *(((double*)field->elems) + field_info_index) = strtod(tmp, &stopstring); 00521 break; 00522 default: 00523 epr_set_err(e_err_invalid_value, 00524 "epr_set_header_field_values: internal error: illegal value type"); 00525 } 00526 ptr_index ++; 00527 } 00528 } 00529 } 00530 00531 00532 epr_uint epr_compare_param(EPR_SProductId* product_id) 00533 { 00534 EPR_SDSD* dsd; 00535 epr_uint of; 00536 00537 epr_clear_err(); 00538 00539 if (product_id == NULL) { 00540 epr_set_err(e_err_invalid_product_id, "epr_compare_param: invalid product identifier"); 00541 return 0UL; 00542 } 00543 00544 of = epr_api.epr_head_size; 00545 dsd = (EPR_SDSD*)epr_get_ptr_array_elem_at(product_id->dsd_array, 0); 00546 if (dsd->ds_offset == epr_api.epr_head_size) 00547 return of; 00548 00549 return 0UL; 00550 }
1.7.6.1