epr_msph.c

Insar图像处理软件

                    epr_free_string(token_value);
                    token_value = NULL;

                    token_unit = epr_str_tok(code_block, seps, &pos);
                } else {
                    /*if CHAR value*/
                    if (strlen(token_value) > 1) {
                        epr_set_err(e_err_invalid_value, 
                                    "epr_parse_header: invalid ascii header: illegal value");
                        token_value = epr_clone_string("");
                        token_unit = NULL;
                        tp = e_tid_uchar;
                        num_bytes = 0;
                        num_elems = 1;
                        epr_add_ptr_array_elem(header_values, token_value);
                        epr_free_string(token_name);
                        if (code_block != NULL) {
                            epr_free_string(code_block);
                            code_block = NULL;
                        }
                        continue;
                    } else {
                        token_unit = NULL;
                        tp = e_tid_uchar;
                        num_bytes = (uint)strlen(token_value);
                        num_elems = 1;
                        epr_add_ptr_array_elem(header_values, token_value);
                    }
                }
            }
        }
        field_info = epr_create_field_info(tp, h_name, token_name, num_elems, num_bytes, 1, token_unit);
        epr_add_ptr_array_elem(field_infos, field_info);
        epr_free_string(token_name);
        epr_free_string(token_unit);
        epr_free_string(code_block); 
    }

    if (field_infos->length > 0) {
        record_info = epr_create_record_info(h_name, field_infos);
        record = epr_create_record_from_info(record_info);
        epr_set_header_field_values(record, header_values);
    }

    epr_free_char_ptr_array(header_values);

    epr_free_string(h_name);

    return record;
}


void epr_parse_string_token(EPR_SPtrArray* header_values, char* token_value, uint* num_elems, uint* num_bytes, EPR_EDataTypeId* tp)
{
    char exceptions[] = EPR_HEADER_EXCEPTIONS_ARRAY;
    char * token_value_o;
    char * tmp;
    uint pos_value = 0;
    int cyc = 0;

    pos_value = 0;
    *num_elems = 0;
    while ((tmp = epr_str_tok_tok(token_value + 1, "+-", exceptions, &pos_value)) != NULL) {
        cyc ++;
        token_value_o = epr_create_string(strlen(tmp) + 1);
        if (strlen(tmp) == strlen(token_value) - 1) {
            token_value_o[0] = token_value[0];
        } else if (pos_value < (uint)strlen(token_value) - 1) {
            token_value_o[0] = token_value[pos_value - strlen(tmp) - 1];
        } else {
            token_value_o[0] = token_value[pos_value - strlen(tmp)];
        }
        strcat(token_value_o, tmp);
        epr_add_ptr_array_elem(header_values, token_value_o);
        epr_free_string(tmp);
    }
    *num_bytes = sizeof(double);
    *tp = e_tid_double;
    *num_elems = cyc;
}

void epr_parse_double_token(EPR_SPtrArray* header_values, char* token_value, uint* num_elems, uint* num_bytes, EPR_EDataTypeId* tp)
{
    char exceptions[] = EPR_HEADER_EXCEPTIONS_ARRAY;
    char * token_value_o;
    char * tmp;
    uint pos_value = 0;
    int cyc = 0;

    pos_value = 0;
    *num_elems = 0;
    while ((tmp = epr_str_tok_tok(token_value + 1, "+-", exceptions, &pos_value)) != NULL) {
        cyc ++;
        token_value_o = epr_create_string(strlen(tmp) + 1);
        if (strlen(tmp) == strlen(token_value) - 1) {
            token_value_o[0] = token_value[0];
        } else if (pos_value < (uint)strlen(token_value) - 1) {
            token_value_o[0] = token_value[pos_value - strlen(tmp) - 1];
        } else {
            token_value_o[0] = token_value[pos_value - strlen(tmp)];
        }
        strcat(token_value_o, tmp);
        epr_add_ptr_array_elem(header_values, token_value_o);
        epr_free_string(tmp);
    }
    *num_bytes = sizeof(double);
    *tp = e_tid_double;
    *num_elems = cyc;
}


void epr_parse_long_token(EPR_SPtrArray* header_values, char* token_value, uint* num_elems, uint* num_bytes, EPR_EDataTypeId* tp)
{
    char * token_value_o;
    char * tmp;
    char * tmp_v;
    char * stopstring;    
    int pos_value = 0;
    uint dlina;
    uint i;
    char value_buffer[32];  
    long lmp;
    ulong ulmp;
    int flag_long = 0;
    int flag_negative = 0;
    int cyc = 0;

    pos_value = 0;
    *num_elems = 0;
    flag_long = 0;
    flag_negative = 0;

    if (strchr(token_value, '-') != NULL) {
        flag_long = 1;
        *num_bytes = sizeof(long);
        *tp = e_tid_long;
    } else {
        *num_bytes = sizeof(ulong);
        *tp = e_tid_ulong;
    }

    while ((tmp = epr_str_tok(token_value + 1, "+-", &pos_value)) != NULL) {
        if (epr_if_no_letters(tmp) == 0) {
            epr_set_err(e_err_invalid_value, 
                        "epr_parse_header: invalid ascii header: illegal value");
            cyc ++;
            tmp = epr_clone_string("-999999");
            *num_bytes = sizeof(long); 
            *tp = e_tid_long;
            epr_add_ptr_array_elem(header_values, tmp);
        } else {
            cyc ++;
            token_value_o = epr_create_string(strlen(tmp) + 1);
            if (strlen(tmp) == strlen(token_value) - 1) {
                token_value_o[0] = token_value[0];
            } else if (pos_value < (int)strlen(token_value) - 1) {
                token_value_o[0] = token_value[pos_value - strlen(tmp) - 1];
            } else if (strlen(tmp) == 1) {
                if (cyc == 1) 
                    token_value_o[0] = token_value[pos_value];
                else 
                    token_value_o[0] = token_value[pos_value - 1];
            } else {
                token_value_o[0] = token_value[pos_value - strlen(tmp)];
            }
            strcat(token_value_o, tmp);
            dlina = (uint)strlen(token_value_o);
            tmp_v = epr_create_string(dlina);
            /*if long*/
            if (flag_long == 1) {
                lmp = strtol(token_value_o, &stopstring, 10);
                if (lmp != 0) {
                    tmp_v[0] = token_value_o[0];
                    for (i = 1; i < dlina; i ++) if (token_value_o[i] != '0') break; 
                    if (token_value_o[0] == '+') strncpy(tmp_v + 0, token_value_o + i, dlina - i);
                    if (token_value_o[0] == '-') strncpy(tmp_v + 1, token_value_o + i, dlina - i);
                    sprintf(value_buffer, "%ld", lmp);
                    /*if long value too large*/
                    if (strcmp(tmp_v, value_buffer) != 0) 
                        epr_log(e_log_warning, "product header: long integer value out of range");
                }
            } else if (flag_long == 0) {
                ulmp = strtoul(token_value_o, &stopstring, 10);
                if (ulmp != 0UL) {
                    tmp_v[0] = token_value_o[0];
                    for (i = 1; i < dlina; i ++) if (token_value_o[i] != '0') break; 
                    strncpy(tmp_v, token_value_o + i, dlina - i);
                    sprintf(value_buffer, "%lu", ulmp);
                    /*if ulong value too large*/
                    if (strcmp(tmp_v, value_buffer) != 0) 
                        epr_log(e_log_warning, "product header: unsigned long integer value out of range");
                }
            }
            epr_free_string(tmp_v);
            epr_add_ptr_array_elem(header_values, token_value_o);
            epr_free_string(tmp);
        }
    }
    *num_elems = cyc;
}



/**
 * Fills the record for the header ASCII information.
 * 
 * @param record to fill;
 * @param header_values values from the given product file;
 * @param record beeng filling.
 */
void epr_set_header_field_values(EPR_SRecord* record, EPR_SPtrArray* header_values)
{
    EPR_SFieldInfo* field_info;
    EPR_SField* field;
    uint ptr_index = 0;
    uint field_index;
    uint field_info_index;
    char * tmp;
    char * stopstring;

    assert(header_values != NULL);

    for (field_index = 0; field_index < record->num_fields; field_index++) {
        field = record->fields[field_index];
        field_info = (EPR_SFieldInfo*)epr_get_ptr_array_elem_at(record->info->field_infos, field_index);

        for (field_info_index = 0; field_info_index < field->info->num_elems; field_info_index++) {
            tmp = (char*)epr_get_ptr_array_elem_at(header_values, ptr_index);
            switch (field_info->data_type_id) {
                case e_tid_uchar:
                    *(((uchar*)field->elems) + field_info_index) = (uchar) tmp[field_info_index];
                    break;
                case e_tid_long:
                    *(((long*)field->elems) + field_info_index) = strtol(tmp, &stopstring, 10);
                    break;
                case e_tid_ulong:
                    *(((ulong*)field->elems) + field_info_index) = strtoul(tmp, &stopstring, 10);
                    break;
                case e_tid_string:;
                    /*epr_assign_string(&(char*)field->elems, tmp);*/
                    strncpy((char*)field->elems, tmp, field->info->tot_size);
                    break;
                case e_tid_double:
                    *(((double*)field->elems) + field_info_index) = strtod(tmp, &stopstring);
                    break;
                default:
                    epr_set_err(e_err_invalid_value, 
                            "epr_set_header_field_values: internal error: illegal value type");
            }
            ptr_index ++;
        }
    }
}


ulong epr_compare_param(EPR_SProductId* product_id)
{
    EPR_SDSD* dsd;
    ulong of;

    epr_clear_err();

    if (product_id == NULL) {
        epr_set_err(e_err_invalid_product_id, "epr_compare_param: invalid product identifier");
        return 0UL;
    }

    of = epr_api.epr_head_size;
    dsd = (EPR_SDSD*)epr_get_ptr_array_elem_at(product_id->dsd_array, 0);
    if (dsd->ds_offset == epr_api.epr_head_size)
        return of;

    return 0UL;
}