int gt_parse_description_range(const char *description, GtRange *range)
{
unsigned long i, desclen;
char *desc, *descptr;
gt_assert(description && range);
desc = gt_cstr_dup(description);
desclen = strlen(desc);
descptr = desc;
/* ignore terminal '\n' */
if (desclen && desc[desclen-1] == '\n') {
desc[desclen-1] = '\0';
desclen--;
}
/* ignore terminal '\r' */
if (desclen && desc[desclen-1] == '\r') {
desc[desclen-1] = '\0';
desclen--;
}
/* find ':' */
for (i = 0; i < desclen; i++) {
if (desc[i] == ':')
break;
}
if (i == desclen) {
/* no ':' found */
gt_free(descptr);
return -1;
}
desc += i + 1;
/* find '..' */
i = 0;
while (desc[i] != '\0') {
if (desc[i-1] == '.' && desc[i] == '.')
break;
i++;
}
if (desc[i] == '\0') {
/* no '..' found */
gt_free(descptr);
return -1;
}
/* parse range start */
gt_assert(desc[i-1] == '.' && desc[i] == '.');
desc[i-1] = '\0';
if (gt_parse_ulong(&range->start, desc)) {
/* parsing failed */
gt_free(descptr);
return -1;
}
/* parse range end */
desc += i + 1;
if (gt_parse_ulong(&range->end, desc)) {
/* parsing failed */
gt_free(descptr);
return -1;
}
gt_free(descptr);
return 0;
}
static int create_block_features(GtBEDParser *bed_parser, GtFeatureNode *fn,
unsigned long block_count,
GtSplitter *size_splitter,
GtSplitter *start_splitter, GtIO *bed_file,
GtError *err)
{
unsigned long i;
int had_err = 0;
gt_assert(fn && block_count && size_splitter && start_splitter);
gt_assert(gt_splitter_size(size_splitter) == block_count);
gt_assert(gt_splitter_size(start_splitter) == block_count);
for (i = 0; !had_err && i < block_count; i++) {
unsigned long block_size, block_start, start, end;
GtGenomeNode *block;
const char *name;
if (gt_parse_ulong(&block_size, gt_splitter_get_token(size_splitter, i))) {
gt_error_set(err, "file \"%s\": line %lu: could not parse blockSize '%s'",
gt_io_get_filename(bed_file),
gt_io_get_line_number(bed_file),
gt_splitter_get_token(size_splitter, i));
had_err = -1;
}
if (!had_err && gt_parse_ulong(&block_start,
gt_splitter_get_token(start_splitter, i))) {
gt_error_set(err, "file \"%s\": line %lu: could not parse blockStart "
"'%s'", gt_io_get_filename(bed_file),
gt_io_get_line_number(bed_file),
gt_splitter_get_token(start_splitter, i));
had_err = -1;
}
if (!had_err) {
start = gt_genome_node_get_start((GtGenomeNode*) fn) + block_start;
end = start + block_size - 1;
block = gt_feature_node_new(gt_genome_node_get_seqid((GtGenomeNode*) fn),
bed_parser->block_type
? bed_parser->block_type
: BED_BLOCK_TYPE,
start, end, gt_feature_node_get_strand(fn));
if ((name = gt_feature_node_get_attribute(fn, "Name")))
gt_feature_node_add_attribute((GtFeatureNode*) block, "Name", name);
gt_feature_node_set_score((GtFeatureNode*) block,
gt_feature_node_get_score(fn));
gt_feature_node_set_strand((GtFeatureNode*) block,
gt_feature_node_get_strand(fn));
gt_feature_node_add_child(fn, (GtFeatureNode*) block);
}
}
return had_err;
}
static int bed_rest(GtBEDParser *bed_parser, GtIO *bed_file, GtError *err)
{
unsigned long block_count = 0;
GtGenomeNode *gn = NULL;
GtRange range;
GtStr *seqid;
int had_err;
gt_error_check(err);
/* column 1.: chrom */
seqid = get_seqid(bed_parser);
had_err = skip_blanks(bed_file, err);
/* column 2.: chromStart */
if (!had_err) {
word(bed_parser->word, bed_file);
had_err = skip_blanks(bed_file, err);
}
/* column 3.: chromEnd */
if (!had_err) {
word(bed_parser->another_word, bed_file);
had_err = parse_bed_range(&range, bed_parser->word,
bed_parser->another_word, bed_parser->offset,
bed_file, err);
}
if (!had_err) {
/* add region */
gt_region_node_builder_add_region(bed_parser->region_node_builder,
gt_str_get(seqid), range);
/* create feature */
gn = gt_feature_node_new(seqid,
bed_parser->feature_type
? bed_parser->feature_type
: BED_FEATURE_TYPE,
range.start, range.end, GT_STRAND_BOTH);
gt_queue_add(bed_parser->feature_nodes, gn);
if (bed_separator(bed_file))
had_err = skip_blanks(bed_file, err);
}
/* optional column 4.: name */
if (!had_err) {
word(bed_parser->word, bed_file);
if (gt_str_length(bed_parser->word)) {
gt_feature_node_add_attribute((GtFeatureNode*) gn, "Name",
gt_str_get(bed_parser->word));
}
if (bed_separator(bed_file))
had_err = skip_blanks(bed_file, err);
}
/* optional column 5.: score */
if (!had_err) {
word(bed_parser->word, bed_file);
if (gt_str_length(bed_parser->word)) {
bool score_is_defined;
float score_value;
had_err = gt_parse_score(&score_is_defined, &score_value,
gt_str_get(bed_parser->word),
gt_io_get_line_number(bed_file),
gt_io_get_filename(bed_file), err);
if (!had_err && score_is_defined)
gt_feature_node_set_score((GtFeatureNode*) gn, score_value);
}
}
if (!had_err && bed_separator(bed_file))
had_err = skip_blanks(bed_file, err);
/* optional column 6.: strand */
if (!had_err) {
word(bed_parser->word, bed_file);
if (gt_str_length(bed_parser->word)) {
GtStrand strand;
had_err = gt_parse_strand(&strand, gt_str_get(bed_parser->word),
gt_io_get_line_number(bed_file),
gt_io_get_filename(bed_file), err);
if (!had_err)
gt_feature_node_set_strand((GtFeatureNode*) gn, strand);
}
}
if (!had_err && bed_separator(bed_file))
had_err = skip_blanks(bed_file, err);
/* optional column 7.: thickStart */
if (!had_err) {
word(bed_parser->word, bed_file);
if (bed_separator(bed_file))
had_err = skip_blanks(bed_file, err);
}
/* optional column 8.: thickEnd */
if (!had_err) {
word(bed_parser->another_word, bed_file);
if (gt_str_length(bed_parser->another_word)) {
gt_assert(gt_str_length(bed_parser->word));
/* got a thickStart and a thickEnd -> construct corresponding feature */
had_err = parse_bed_range(&range, bed_parser->word,
bed_parser->another_word, bed_parser->offset,
bed_file, err);
if (!had_err)
construct_thick_feature(bed_parser, (GtFeatureNode*) gn, range);
}
}
if (!had_err && bed_separator(bed_file))
had_err = skip_blanks(bed_file, err);
/* optional column 9.: itemRgb */
if (!had_err) {
word(bed_parser->word, bed_file);
/* we do not use the RGB values */
if (bed_separator(bed_file))
had_err = skip_blanks(bed_file, err);
}
/* optional column 10.: blockCount */
if (!had_err) {
word(bed_parser->word, bed_file);
if (gt_str_length(bed_parser->word)) {
if (gt_parse_ulong(&block_count, gt_str_get(bed_parser->word))) {
gt_error_set(err, "file \"%s\": line %lu: could not parse blockCount",
gt_io_get_filename(bed_file),
gt_io_get_line_number(bed_file));
had_err = -1;
}
else {
/* reset to parse/process blockSizes and blockStarts properly */
gt_str_reset(bed_parser->word);
gt_str_reset(bed_parser->another_word);
}
}
}
if (!had_err && bed_separator(bed_file))
had_err = skip_blanks(bed_file, err);
/* optional column 11.: blockSizes */
if (!had_err) {
word(bed_parser->word, bed_file);
if (bed_separator(bed_file))
had_err = skip_blanks(bed_file, err);
}
/* optional column 12.: blockStarts */
if (!had_err) {
word(bed_parser->another_word, bed_file);
if (bed_separator(bed_file))
had_err = skip_blanks(bed_file, err);
}
/* process blocks if necessary */
if (!had_err && block_count) {
had_err = process_blocks(bed_parser, (GtFeatureNode*) gn, block_count,
bed_parser->word, bed_parser->another_word,
bed_file, err);
}
/* the end of the line should now be reached */
if (!had_err)
had_err = gt_io_expect(bed_file, GT_END_OF_LINE, err);
return had_err;
}