Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/alnread_8c_source.html below:

NCBI C++ ToolKit: src/util/creaders/alnread.c Source File

* val_name,

* errformat =

;

eip->

= (

*)

(strlen (errformat) + strlen (val_name)

errfunc (eip, errdata);

* err_format =

;

(errfunc ==

|| num_bad == 0 || bad_char == 0

|| reason ==

) {

+ strlen (reason) + 3);

sprintf (eip->

, err_format, num_bad, bad_char,

, reason);

errfunc (eip, errdata);

* report_error_userdata)

(report_error ==

) {

report_error (eip, report_error_userdata);

* report_error_userdata)

(report_error ==

) {

eip->

=

(

);

report_error (eip, report_error_userdata);

* report_error_userdata)

*

=

;

(lip ==

|| report_error ==

) {

report_error(eip, report_error_userdata);

* report_error_userdata)

* err_format =

;

(report_error ==

) {

sprintf (eip->

, err_format, expected_num, actual_num);

report_error (eip, report_error_userdata);

* report_error_userdata)

* err_format =

;

(report_error ==

) {

report_error (eip, report_error_userdata);

* report_error_userdata)

(report_error ==

) {

report_error (eip, report_error_userdata);

* report_error_userdata)

* format_str =

;

(report_error ==

) {

sprintf (eip->

, format_str, expected_length, actual_length);

report_error (eip, report_error_userdata);

* report_error_userdata)

* err_format =

;

(report_error ==

) {

sprintf (eip->

, err_format, num_expected, num_found);

report_error (eip, report_error_userdata);

* report_error_userdata)

* err_format =

;

(report_error ==

) {

sprintf (eip->

, err_format, len_expected, len_found);

report_error (eip, report_error_userdata);

* report_error_userdata)

(report_error ==

) {

report_error (eip, report_error_userdata);

* report_error_userdata)

* err_format =

;

line_number !=

;

line_number = line_number->

) {

sprintf(cp,

, line_number->

);

report_error(eip, report_error_userdata);

*

=

;

(errfunc ==

) {

errfunc (eip, errdata);

*

=

;

num_lines = 0;

* line_text_list;

* line_text_list_offset;

(errfunc ==

|| offset_list ==

) {

(

= offset_list;

!=

;

=

->next) {

line_text_list = (

*)

(msg_len);

(line_text_list ==

)

;

line_text_list_offset = line_text_list;

(

= offset_list;

!=

;

=

->next) {

(

->next ==

)

sprintf (line_text_list_offset,

,

->ival);

(num_lines == 2)

sprintf (line_text_list_offset,

,

->ival);

(

->next->next ==

)

sprintf (line_text_list_offset,

,

->ival);

sprintf (line_text_list_offset,

,

->ival);

line_text_list_offset += strlen (line_text_list_offset);

msg_len += strlen(

) + 1;

sprintf(eip->

,

, line_text_list);

errfunc(eip, errdata);

(line_text_list);

*

=

;

(errfunc ==

|| linestring ==

) {

eip->

= (

*)

(strlen (

) + strlen (linestring) + 1);

errfunc (eip, errdata);

*

=

;

(errfunc ==

) {

sprintf (eip->

,

, num_seg, num_seg_exp);

errfunc (eip, errdata);

(

line_num_start,

* errformat1 =

;

* errformat2 =

;

* errformat3 =

;

(errfunc ==

|| line_val ==

) {

(line_num_start == line_num_stop) {

sprintf (eip->

, errformat1, line_num_start);

sprintf (eip->

, errformat2, line_num_start,

errfunc (eip, errdata);

(skip = line_num_start;

skip < line_num_stop + 1 && line_val !=

;

+ strlen (line_val->

) + 1);

sprintf (eip->

, errformat3, line_val->

);

errfunc (eip, errdata);

line_val = line_val->

;

(list ==

) {

(best ==

) {

(

==

||

->size_value != size_value) {

->num_appearances ++;

sip1 = sip1->

, sip2 = sip2->

) {

(list ==

) {

prev_llp = prev_llp->

;

prev_llp->

= llp;

(

*

,

(lip !=

) {

next_lip = lip->

;

(lip !=

) {

nextlip = lip->

;

*

,

(

==

) {

(list ==

) {

*

,

(comment ==

) {

(list !=

) {

list = list->

;

list->

= comment;

(list ==

) {

*

,

(comment ==

) {

num_segments = 0;

skipped_line_since_last_defline =

;

(lip->

[0] !=

|| strspn(lip->

+ 1,

) != strlen (lip->

+ 1))

(lip->

[0] ==

)

(!skipped_line_since_last_defline)

skipped_line_since_last_defline =

;

skipped_line_since_last_defline =

;

(lip->

[0] !=

|| strspn (lip->

+ 1,

) != strlen (lip->

+ 1)))

num_segments;

num_segments = 1;

num_segments_this_bracket;

num_segments_expected;

(comment_list ==

)

num_segments;

(comment = comment_list; comment !=

; comment = comment->

)

num_segments_this_bracket,

(comment != comment_list && segcount_list->

!=

)

(num_segments_expected != num_segments_this_bracket)

num_segments_this_bracket, num_segments_expected,

num_segments;

(comment_list ==

)

(comment = comment_list; comment !=

; comment = comment->

)

(offset_list ==

) offset_list = new_offset;

first_token =

;

(lip = line_list; lip !=

; lip = lip->

) {

(piece !=

) {

line_pos = piece -

;

(list ==

) {

(lip = list; lip !=

; lip = lip->

) {

(lip = list; lip !=

; lip = lip->

) {

cp_from = lip->

;

(*cp_from != 0) {

(!

((

)*cp_from)) {

(lirp ==

) {

(line_list ==

) {

(lirp ==

) {

(lirp ==

) {

(new_item ==

) {

->next = new_item;

(list ==

) {

(

==

) {

add_to = add_to->

) {

add_to = add_to->

) {

(add_to ==

) {

(list ==

) list = add_to;

(add_to !=

) {

(add_to !=

) {

char_count, diff;

(str1 ==

&& str2 ==

) {

(str1 ==

) {

(str2 ==

) {

(*cp1 != 0 && *cp2 != 0 && char_count < cmp_count) {

diff =

((

)(*cp1)) -

((

)(*cp2));

(char_count == cmp_count) {

}

(*cp1 == 0 && *cp2 != 0) {

}

(*cp1 != 0 && *cp2 == 0) {

(str1 ==

&& str2 ==

) {

(str1 ==

) {

(str2 ==

) {

(*cp1 != 0 && *cp2 != 0) {

diff =

((

) *cp1) -

((

) *cp2);

(*cp1 == 0 && *cp2 != 0) {

}

(*cp1 != 0 && *cp2 == 0) {

(!

((

)*cp) && *cp != 0) {

(

((

)*cpend) && *cpend != 0) {

(!

((

)*cp) && *cp != 0) {

(

((

)*cpend) && *cpend != 0) {

(

> 0 && second > 0) {

(!

((

)*cp) && !

((

)*cp)) {

(! found_first_number) {

(!

((

)*cp)) {

found_first_number =

;

}

(! found_dividing_space) {

(

((

) *cp)) {

found_dividing_space =

;

}

( !

((

)*cp)) {

}

(! found_second_number) {

(

((

)*cp)) {

found_second_number =

;

}

(!

((

) *cp)) {

}

(! found_second_number_end) {

(

((

) *cp)) {

found_second_number_end =

;

}

(!

((

)*cp)) {

}

(!

((

) *cp)) {

(found_second_number) {

(

*

,

* valname,

cpstart = (

*) strstr (

, valname);

(cpstart ==

) {

cpstart += strlen (valname);

(*cpstart != 0 &&

((

)*cpstart)) {

(*cpstart !=

) {

(*cpstart != 0 &&

((

)*cpstart)) {

(!

((

)*cpstart)) {

cpend = cpstart + 1;

( *cpend != 0 &&

((

)*cpend)) {

maxlen = cpend - cpstart;

strncpy(

, cpstart, maxlen);

(

*

,

* found_nchar,

|| found_ntax ==

|| afrp ==

) {

(! *found_ntax &&

*found_ntax =

;

(! *found_nchar &&

*found_nchar =

;

cpend = strstr (

,

);

(cpend ==

) {

cp = strstr (

, val_name);

(cp ==

|| cp > cpend) {

cp += strlen (val_name);

(

((

)*cp)) {

(

((

)*cp) || *cp ==

) {

(

*

,

cp = strstr (

,

);

cp = strstr (

,

);

(errfunc ==

) {

(c != 0 && sequence_info->

!=

&& strchr (sequence_info->

, c) ==

)

|| *(

+ 1) != 0)

= (

*)

(2 *

(

));

(

*

,

cp = (

*) strstr (

,

);

cp = (

*) strstr (

,

);

|| strspn (

,

) < strlen (

)

|| (strchr (

,

) ==

&& strchr (

,

) ==

&& strchr (

,

) ==

)) {

* last_semicolon;

last_semicolon = strrchr (

,

);

(last_semicolon ==

|| strspn (last_semicolon + 1,

) != strlen (last_semicolon + 1)

|| strchr (

,

) != last_semicolon) {

(*

!= 0) {

||

[0] ==

) {

= strspn (

,

);

(

== strlen (

)) {

(linestring ==

) {

(linestring !=

&& strstr (linestring,

) !=

) {

(

==

) {

cp_start = strstr (

,

);

(cp_start !=

) {

cp_end = strstr (cp_start,

);

(cp_end !=

) {

clp->

= cp_start;

(linestring ==

) {

(clp !=

) {

strcpy (clp->

, clp->

+ 1);

( linestring [0] ==

) {

(linestring[

] == 0) {

(strspn (linestring,

) == strlen (linestring)) {

= strspn ( clp->

,

);

cp_end = strstr (cp,

);

(cp_end ==

) {

(cp_end > cp &&

((

)*cp_end)) {

((cp_end - cp == 3 &&

(cp,

, 3) == 0)

|| (cp_end - cp == 8 &&

(cp,

, 8) == 0)) {

(

==

) {

* pos = clp->

;

(next_clp !=

&&

clp->

= next_clp->

;

pbuf1024[1024];

* to = clp->

;

* from = clp->

+ 1;

diff = from - to;

= strlen(from);

(diff <

-1) {

* pbuf = pbuf1024;

(

>

(pbuf1024)-1) {

strcpy(pbuf, clp->

+ 1);

strcpy(clp->

, pbuf);

(pbuf != pbuf1024) {

strcpy (clp->

, clp->

+ 1);

next_len, this_len,

;

(org_clp ==

) {

ordered_start =

;

(ordered_start ==

) {

next_clp = ordered_start;

next_len = next_clp->

- next_clp->

;

this_len = clp->

- clp->

;

= next_len > this_len ? next_len : this_len;

(next_clp !=

prev_clp = next_clp;

next_clp = next_clp->

;

(next_clp !=

) {

next_len = next_clp->

- next_clp->

;

= next_len > this_len ? next_len : this_len;

(prev_clp ==

) {

clp->

= ordered_start;

ordered_start = clp;

prev_clp->

= clp;

clp_list->

= ordered_start;

* ordered_org_name;

(org_clp ==

) {

ordered_org_name = (

*)

(org_clp->

- org_clp->

+ 2);

(ordered_org_name ==

) {

ordered_org_name [0] = 0;

cp = ordered_org_name;

(clp = clp_list; clp !=

; clp = clp->

) {

ordered_org_name;

org_num, defline_num, new_len;

*empty_defline, *new_defline;

(afrp ==

|| defline ==

) {

(lip !=

)

(lip !=

&& defline_num < org_num) {

(defline_num == org_num && lip !=

) {

(strlen (lip->

) == 0)

lip->

= defline;

new_len = strlen (lip->

) + strlen (defline) + 2;

new_defline = (

*)

(new_len *

(

));

(new_defline !=

)

strcpy (new_defline, lip->

);

(new_defline,

);

(new_defline, defline);

lip->

= new_defline;

(defline_num < org_num - 1)

empty_defline = (

*)

(

(

));

(empty_defline !=

)

(

==

||

[0] !=

|| afrp ==

) {

(clp ==

&& (strstr (

,

) !=

|| strstr (

,

) !=

))

linelen = strlen(

);

(clp !=

) {

clp->

-

);

(*clp->

!= 0) {

cp += strspn (cp,

);

defline = clp->

+ 1;

defline_offset = clp->

-

+ 1;

comment_end = clp->

;

(arsp ==

) {

(arsp ==

) {

(arsp = list; arsp !=

; arsp = arsp->

) {

(

(arsp->

,

) == 0) {

(

(arsp->

,

) == 0) {

arsp = arsp->

;

data_line_offset)

(arsp ==

) {

(arsp ==

) {

(list ==

) list = arsp;

data_line_offset)

(arsp = list; arsp !=

&& curr < index; arsp = arsp->

) {

(arsp ==

) {

(afrp ==

) {

(afrp ==

) {

(this_pattern ==

) {

= strcspn (cp,

);

cp += strspn (cp,

);

this_pattern;

line_counter = line_start;

(next_offset !=

&& next_offset->

- line_counter < block_size) {

(llp = pattern_list;

&& (next_offset ==

|| line_counter < next_offset->

- 1)

&& line_counter - line_start < block_size;

(line_counter - line_start == block_size) {

prev_offset =

;

next_offset = offset_list;

(llp !=

) {

(next_offset !=

&& line_counter == next_offset->

) {

prev_offset = next_offset;

next_offset = next_offset->

;

(line_counter - prev_offset->

< block_size

(forecast_pos > 0) {

(new_offset ==

) {

(prev_offset ==

) {

new_offset->

= offset_list;

offset_list = new_offset;

new_offset->

= next_offset;

prev_offset->

= new_offset;

prev_offset = new_offset;

(line_counter - prev_offset->

< block_size

block_line_counter;

(pattern_list ==

|| afrp ==

(llp !=

&& line_val !=

) {

(llp !=

&& line_val !=

&& (

==

|| line_counter < offset->ival)) {

line_val = line_val->

;

block_line_counter = 0;

(block_line_counter < afrp->block_size && llp !=

) {

line_val = line_val->

;

(llp = pattern_list; llp !=

; llp = llp->

) {

llp_next = llp->

;

(size_list ==

) {

(best_ptr !=

(llp = pattern_list; llp !=

; llp = llp->

) {

llp_next = llp->

;

(new_offset ==

) {

(ppline ==

|| *ppline ==

) {

= strlen (*ppline);

ptmp = *ppline +

- 1;

(ptmp > *ppline && (*ptmp ==

|| *ptmp ==

|| *ptmp ==

|| *ptmp ==

))

= strspn (*ppline,

);

overall_line_count = 0;

* linestring = readfunc (pfile);

(linestring !=

&& linestring [0] != EOF) {

(in_taxa_comment) {

(

(linestring,

, 4) == 0) {

in_taxa_comment =

;

}

(

(linestring,

, 11) == 0) {

in_taxa_comment =

;

next_line =

(linestring, overall_line_count, 0);

(last_line ==

) {

last_line->

= next_line;

last_line = next_line;

linestring = readfunc (pfile);

overall_line_count ++;

* last_line_was_marked_id,

overall_line_count)

(last_pattern !=

) {

(last_pattern->

!=

) {

last_pattern = last_pattern->

;

(linestr [0] ==

) {

(*last_line_was_marked_id)

*last_line_was_marked_id =

;

*last_line_was_marked_id =

;

= strcspn (linestr,

);

cp = linestr +

;

= strspn (cp,

);

(last_pattern ==

) {

last_pattern->

= this_pattern;

use_nexus_file_info,

overall_line_count;

(readfunc ==

|| sequence_info ==

) {

(afrp ==

) {

(next_line = afrp->

; next_line !=

; next_line = next_line->

) {

linestring = next_line->

;

overall_line_count = next_line->

-1;

(afrp, & pattern_list, & last_line_was_marked_id, linestring, overall_line_count);

(! found_expected_ntax || ! found_expected_nchar) {

found_expected_ntax =

;

found_expected_nchar =

;

&found_expected_nchar, afrp);

(! found_char_comment) {

(use_nexus_file_info) {

(in_bracketed_comment) {

= strspn (linestring,

);

(last_comment !=

)

overall_line_count,

);

(strchr (linestring,

) !=

) {

in_bracketed_comment =

;

}

(linestring [0] ==

&& strchr (linestring,

) ==

) {

in_bracketed_comment =

;

= strspn (linestring,

);

overall_line_count,

);

(comment_list ==

)

comment_list = last_comment;

(linestring[0] == 0) {

last_line_was_marked_id =

;

(pattern_list ==

) {

pattern_list = this_pattern;

last_pattern = this_pattern;

last_pattern->

= this_pattern;

last_pattern = this_pattern;

(linestring [0] ==

) {

(last_line_was_marked_id)

(afrp, & pattern_list, & last_line_was_marked_id, linestring, overall_line_count);

last_line_was_marked_id =

;

last_line_was_marked_id =

;

= strcspn (linestring,

);

cp = linestring +

;

= strspn (cp,

);

(pattern_list ==

) {

pattern_list = this_pattern;

last_pattern = this_pattern;

last_pattern->

= this_pattern;

last_pattern = this_pattern;

num_lines_in_block)

(lip = first_line, block_offset = 0;

lip !=

&& block_offset < num_lines_in_block;

lip = lip->

, block_offset++)

linestring = lip->

;

(linestring !=

) {

= strcspn (linestring,

);

(

> 0 &&

< strlen (linestring)) {

(this_id ==

) {

strncpy (this_id, linestring,

);

this_id [

] = 0;

(arsp !=

) {

num_lines_in_block,

, block_offset, id_offset;

(lip = first_line, block_offset = 0;

lip !=

&& block_offset < num_lines_in_block;

lip = lip->

, block_offset ++)

= strcspn (cp,

);

(first_block &&

== strlen (cp)) {

tmp_id = (

*)

( (

+ 1) *

(char));

(tmp_id ==

) {

strncpy (tmp_id, cp,

);

(id_offset != block_offset && ! first_block) {

cp += strspn (cp,

);

(this_pattern = list;

this_pattern !=

;

this_pattern = this_pattern->

)

best = this_pattern;

(lip = first_line, block_offset = 0;

lip !=

&& block_offset < num_lines_in_block;

lip = lip->

, block_offset ++)

= strcspn (cp,

);

(first_block &&

== strlen (cp)) {

tmp_id = (

*)

( (

+ 1) *

(char));

(tmp_id ==

) {

strncpy (tmp_id, cp,

);

cp += strspn (cp,

);

num_lines_in_block,

this_block_has_ids;

(lip = lines, line_number = 0;

lip !=

&& line_number < num_lines_in_block;

lip = lip->

, line_number ++)

linestring = lip->

;

(linestring !=

) {

(this_block_has_ids) {

= strcspn (linestring,

);

(first_block &&

== strlen (linestring)) {

(this_id ==

) {

strncpy (this_id, linestring,

);

this_id [

] = 0;

cp = linestring +

;

= strspn (cp,

);

num_lines_in_block)

(lip = first_line, block_offset = 0;

lip !=

&& block_offset < num_lines_in_block;

(afrp ==

) {

(lip !=

&& offset_ptr !=

(in_taxa_comment) {

in_taxa_comment =

;

&&

(lip->

,

, 11) == 0) {

in_taxa_comment =

;

(line_counter == offset_ptr->

) {

offset_ptr = offset_ptr->

;

gen_local_ids)

pattern_line_counter;

next_local_id = 1;

(token_list ==

|| offset_list ==

|| anchorpattern ==

(curr_seg = 0; curr_seg < afrp->

; curr_seg ++)

(anchorpattern [curr_seg] ==

|| anchorpattern [curr_seg]->lengthrepeats ==

)

(offset_ptr = offset_list;

offset_ptr !=

&& lip !=

;

offset_ptr = offset_ptr->

)

next_offset_ptr = offset_ptr->

;

(line_counter < offset_ptr->ival - 1 && lip !=

) {

(gen_local_ids) {

* replacement_id = (

*)

(32 +strlen(lip->

));

sprintf(replacement_id,

, next_local_id++, lip->

+1);

lip->

= replacement_id;

curr_id = lip->

;

(sip = anchorpattern[curr_seg]->lengthrepeats;

&& (next_offset_ptr ==

|| line_counter < next_offset_ptr->ival - 1);

(pattern_line_counter = 0;

pattern_line_counter < sip->num_appearances

&& (next_offset_ptr ==

|| line_counter < next_offset_ptr->ival - 1);

pattern_line_counter ++)

(lip->

[0] !=

&& lip->

[0] !=

) {

((

) strlen (lip->

) != sip->size_value) {

line_counter - offset_ptr->

,

(curr_seg = 0; curr_seg < afrp->

; curr_seg ++)

list[curr_seg] =

;

(curr_seg = 0; curr_seg < afrp->

+ 1; curr_seg ++)

best[curr_seg] =

;

this_pattern =

;

(lip->

==

)

;

(lip->

[0] ==

|| lip->

[0] ==

)

;

(lip->

[0] ==

) {

(this_pattern !=

) {

(this_pattern ==

) {

(curr_seg = 0; curr_seg < afrp->

; curr_seg ++)

}

(this_pattern !=

) {

(

((

)*cp) ||

((

)*cp)) {

(this_pattern !=

) {

(curr_seg = 0; curr_seg < afrp->

; curr_seg++)

(this_pattern = list [curr_seg];

this_pattern !=

;

this_pattern = this_pattern->

)

(best [curr_seg] ==

best[curr_seg] = this_pattern;

(best [curr_seg] !=

) {

(best [curr_seg] != list [curr_seg]) {

this_pattern = list [curr_seg];

( this_pattern !=

&& this_pattern->

!= best[curr_seg] ) {

this_pattern = this_pattern->

;

(this_pattern !=

) {

(curr_seg = 0; curr_seg < afrp->

; curr_seg ++)

(best[curr_seg] ==

)

(curr_seg = 0; curr_seg < afrp->

; curr_seg ++)

next_offset = this_offset->

;

(lip !=

&& this_offset !=

) {

(line_count == this_offset->

) {

(lip !=

&&

(next_offset ==

|| line_count < next_offset->ival - 1)) {

cp += strspn (cp,

);

(cp != lip->

) {

strcpy (lip->

, cp);

this_offset = this_offset->

;

(this_offset !=

) {

next_offset = this_offset->

;

gen_local_ids)

(afrp ==

) {

anchorpattern, afrp, gen_local_ids);

(anchorpattern);

(cp_from == cp_to || cp_from ==

|| cp_to ==

) {

(*cp_to != 0) {

num_comment_starts;

num_comment_starts = 0;

(lip = list; lip !=

; lip = lip->

) {

(cp = lip->

; *cp != 0; cp++) {

(cp_r ==

) {

cp = lip->

- 1;

(cp_r > lip->

) {

(cp_r >= lip->

&& *cp_r !=

) {

(cp_r < lip->

) {

(num_comment_starts > 0) {

num_comment_starts --;

}

(*cp ==

) {

num_comment_starts ++;

(num_comment_starts == 0) {

}

(num_comment_starts > 0) {

cp_r = strchr (lip->

,

);

(cp_r !=

) {

in_comment =

;

(lip->

[0] == 0) {

(lip !=

) {

(end_lip !=

end_lip = end_lip->

;

(end_lip !=

) {

(start_lip != end_lip) {

start_lip = start_lip->

;

lip = end_lip->

;

list_ptr, new_list, best_ptr, return_best;

(list_ptr = list; list_ptr !=

; list_ptr = list_ptr->

) {

(not_this_size != list_ptr->

) {

return_best =

;

(best_ptr !=

) {

(return_best !=

) {

last_line_lengths, sip, sip_next, twoafter;

best_last_line_length;

anchor_line_length;

(anchorpattern ==

|| line_lengths ==

) {

last_line_lengths =

;

(sip = line_lengths; sip !=

; sip = sip->

) {

sip_next = sip->

;

(sip_next !=

&& sip_next->

!= anchor_line_length

&& ((twoafter = sip_next->

) ==

|| twoafter->

!= anchor_line_length))

(best_last_line_length > 0) {

not_this_length;

patternlist =

;

(sip = list; sip !=

; sip = sip->

) {

(newpattern ==

) {

(patternlist ==

) {

(index = patternlist; index !=

; index = index->

) {

index = patternlist;

( index !=

&& index->

!= best ) {

index = index->

;

(index !=

) {

(best !=

) {

&& popular_line_length !=

not_this_length = popular_line_length->

;

|| (popular_line_length !=

(best ==

) {

(best ==

) {

(list ==

|| anchorpattern ==

) {

offset_list =

;

(sip = list; sip !=

; sip = sip->

) {

(new_offset ==

) {

(offset_list ==

) {

offset_list = new_offset;

line_counter, num_chars;

(list ==

) {

line_counter = line_start +

;

(num_chars < pattern_length

&& (next_offset ==

|| line_counter < next_offset->ival)

(end_offset = 0;

&& num_chars < pattern_length

&& (next_offset ==

|| line_counter < next_offset->ival);

(num_chars == pattern_length) {

line_start +

;

line_counter, forecast_position, line_skip;

num_additional_offsets = 0;

max_additional_offsets = 5000;

(list ==

|| anchorpattern ==

) {

(pattern_length == 0) {

prev_offset =

;

next_offset = offset_list;

(sip !=

&& num_additional_offsets < max_additional_offsets) {

(next_offset !=

&& line_counter > next_offset->

) {

next_offset = next_offset->

;

}

(next_offset !=

&& line_counter == next_offset->

) {

skipped_previous =

;

prev_offset = next_offset;

next_offset = next_offset->

;

(num_chars < pattern_length && sip !=

) {

}

(skipped_previous) {

(sip !=

&& line_skip < sip->num_appearances

&& num_additional_offsets < max_additional_offsets

&& (next_offset ==

|| line_counter < next_offset->ival)) {

next_offset, line_skip,

(forecast_position > 0) {

num_additional_offsets++;

(new_offset ==

) {

(prev_offset ==

) {

new_offset->

= offset_list;

offset_list = new_offset;

new_offset->

= next_offset;

prev_offset->

= new_offset;

prev_offset = new_offset;

(num_chars < pattern_length && sip !=

) {

&& num_chars < pattern_length;

skipped_previous =

;

(num_additional_offsets >= max_additional_offsets)

offset_list =

;

line_counter, best_length;

(offset_list ==

) {

pattern_length_list =

;

(line_counter != -1) {

->ival - line_counter);

line_counter =

->ival;

line_diff, num_chars, best_num_chars;

(token_list ==

|| offset_list ==

|| block_length < 1) {

prev_offset =

;

(new_offset = offset_list;

new_offset !=

&& lip !=

;

new_offset = new_offset->

)

(prev_offset ==

) {

line_diff < new_offset->

&& lip !=

;

(prev_offset !=

) {

line_diff < new_offset->

- prev_offset->

(line_diff < new_offset->ival - prev_offset->

- 1) {

num_chars += strlen (lip->

);

(new_offset->

- prev_offset->

== block_length) {

prev_offset = new_offset;

(best_num_chars == 0 && pattern_length_list !=

) {

best_num_chars = pattern_length_list->

;

pattern_length_list =

;

best_num_chars;

desired_num_chars)

num_chars, total_chars, pattern_length, num_starts;

length_list, start_list, start_ptr, length;

start_of_unknown;

num_additional_offsets_needed;

(list ==

|| distance == 0 || desired_num_chars == 0) {

(lip = list, line_diff = 0;

lip !=

&& line_diff < distance

&& total_chars < desired_num_chars;

lip = lip->

, line_diff++) {

num_chars = strlen (lip->

);

total_chars += num_chars;

(lip ==

|| line_diff == distance) {

start_of_unknown = line_diff;

length_list =

;

lip !=

&& line_diff < distance;

lip = lip->

, line_diff++)

num_chars = strlen (lip->

);

(length_list ==

) {

length_list = length;

total_chars += num_chars;

num_additional_offsets_needed = (total_chars / desired_num_chars);

(num_additional_offsets_needed == 0) {

(start_ptr = length_list, line_diff = start_of_unknown;

start_ptr !=

&& line_diff < distance

&& pattern_length < distance - line_diff ;

start_ptr = start_ptr->

, line_diff++) {

num_chars = start_ptr->

;

length = start_ptr->

;

(num_chars < desired_num_chars

&& pattern_length + line_diff < distance

num_chars += length->

;

length = length->

;

(num_chars == desired_num_chars) {

(start_list ==

) {

start_list = length;

prev_offset, new_offset, splice_offset;

line_diff, num_chars, line_start;

(token_list ==

|| offset_list ==

|| block_length < 1 || best_num_chars < 1)

prev_offset =

;

(new_offset = offset_list;

new_offset !=

&& lip !=

;

new_offset = new_offset->

) {

(prev_offset ==

) {

line_diff < new_offset->

&& lip !=

;

(new_offset->

- prev_offset->

== block_length) {

line_diff < new_offset->

- prev_offset->

line_diff < new_offset->

- prev_offset->

&& lip !=

&& num_chars < best_num_chars;

num_chars += strlen (lip->

);

(line_diff < new_offset->ival - prev_offset->

) {

line_start = line_diff + prev_offset->

;

(line_diff < new_offset->ival - prev_offset->

(splice_offset ==

) {

splice_offset->

= new_offset;

prev_offset->

= splice_offset;

new_offset->

- splice_offset->

,

prev_offset = new_offset;

line_diff < block_length && lip !=

;

(cp =

; *cp != 0; cp++) {

(

((

)(*cp))) {

(lip = token_list;

anchorpattern [1] =

;

(anchorpattern [0] ==

|| anchorpattern[0]->lengthrepeats ==

) {

(best_length < 1 && offset_list != NULL && offset_list->

!=

) {

best_length = offset_list->

->

- offset_list->

;

anchorpattern, afrp,

);

(index = 0; index < afp->

; index++) {

cp += strspn (

,

);

= strcspn (cp,

);

strncpy (

, cp,

);

cp += strspn (

,

);

= strcspn (cp,

);

= strspn (cp,

);

(afrp ==

) {

(scp = list; scp !=

; scp = scp->

) {

* reason,

* report_error_userdata)

bad_line_num, bad_line_offset;

bad_char, curr_char;

data_position = lirp->

+ 1;

bad_line_offset, bad_line_num, reason,

report_error, report_error_userdata);

data_position;

* report_error_userdata)

middle_start = 0;

curr_char, master_char;

found_middle_start;

match_not_in_beginning_gap;

match_not_in_end_gap;

beginning_gap =

;

middle_gap =

;

end_gap =

;

(strlen(sip->

) > 0 &&

(arsp ==

|| master_arsp ==

|| sip ==

) {

(lirp ==

) {

(arsp != master_arsp) {

(master_lirp ==

) {

master_lirp =

;

match_not_in_beginning_gap =

;

match_not_in_beginning_gap =

;

match_not_in_end_gap =

;

match_not_in_end_gap =

;

found_middle_start =

;

(curr_char != 0) {

(! found_middle_start) {

middle_start = data_position;

found_middle_start =

;

middle_end = data_position + 1;

}

(! found_middle_start) {

(match_not_in_beginning_gap

&& strchr (sip->

, curr_char) !=

)

middle_start = data_position;

found_middle_start =

;

middle_end = data_position + 1;

,

report_error, report_error_userdata);

(match_not_in_end_gap

&& strchr (sip->

, curr_char) !=

)

middle_end = data_position + 1;

(! found_middle_start) {

(num_segments > 1)

report_error, report_error_userdata);

data_position = middle_start;

(data_position < middle_end)

(data_position < middle_end

(curr_char == 0 || data_position >= middle_end) {

}

(strchr (sip->

, curr_char) !=

) {

}

(strchr (sip->

, curr_char) !=

) {

(master_char == 0) {

(master_arsp == arsp) {

,

report_error, report_error_userdata);

,

report_error, report_error_userdata);

,

report_error, report_error_userdata);

data_position = middle_end;

(curr_char != 0) {

(strchr (sip->

, curr_char) ==

) {

,

report_error, report_error_userdata);

* sizeof (

*));

* sizeof (

*));

* sizeof (

*));

(lip = afrp->

, index = 0;

lip !=

&& index < afp->num_deflines;

lip = lip->

, index++) {

(index < afp->num_deflines) {

(lip = afrp->

, index = 0;

lip !=

&& index < afp->num_organisms;

lip = lip->

, index++) {

(lengths ==

) {

(best_length ==

) {

(curr_seg = 0; curr_seg < afrp->

; curr_seg ++) {

lengths [curr_seg] =

;

best_length [curr_seg] = 0;

(arsp = afrp->

, index = 0;

arsp !=

&& index < afp->num_sequences;

arsp = arsp->

, index++) {

(curr_seg = 0; curr_seg < afrp->

; curr_seg ++)

(best_length [curr_seg] == 0 && lengths [curr_seg] !=

) {

best_length [curr_seg] = lengths [curr_seg]->

;

}

((

) strlen (afp->

[index]) != best_length [curr_seg]) {

(curr_seg = 0; curr_seg < afrp->

; curr_seg ++)

* fileuserdata,

* erroruserdata,

use_nexus_file_info,

gen_local_ids)

(use_nexus_file_info != 0)

errfunc, erroruserdata, &

);

(afrp ==

) {

afrp, gen_local_ids);

* fileuserdata,

* erroruserdata,

use_nexus_file_info)

sequence_info, use_nexus_file_info,

);

* fileuserdata,

* erroruserdata,

* fileuserdata,

* erroruserdata,

gen_local_ids)

sequence_info,

, gen_local_ids);

static EBool s_SkippableString(char *str)

struct SAlignRawSeq SAlignRawSeq

static int s_ForecastPattern(int line_start, int pattern_length, TIntLinkPtr next_offset, int sip_offset, TSizeInfoPtr list)

void AlignmentFileFree(TAlignmentFilePtr afp)

static void s_CreateSequencesBasedOnTokenPatterns(TLineInfoPtr token_list, TIntLinkPtr offset_list, SLengthListPtr *anchorpattern, SAlignRawFilePtr afrp, EBool gen_local_ids)

static TLineInfoPtr s_LineInfoNew(const char *string, int line_num, int line_offset)

static void s_ProcessAlignFileRawByLengthPattern(SAlignRawFilePtr afrp)

static void s_BracketedCommentListFree(TBracketedCommentListPtr list)

TAlignmentFilePtr AlignmentFileNew(void)

static void s_RemoveBasePairCountCommentsFromData(SAlignRawFilePtr afrp)

static int s_FindAlignRawSeqOffsetById(TAlignRawSeqPtr list, char *id)

static char * s_ReplaceNexusTypeChar(char *str, char c)

static int s_ForecastBlockPattern(SLengthListPtr pattern_list, TIntLinkPtr next_offset, int line_start, int block_size)

static void s_AddDeflineFromOrganismLine(char *defline, int line_num, int defline_offset, SAlignRawFilePtr afrp)

static TLineInfoPtr s_BuildTokenList(TLineInfoPtr line_list)

static void s_ReportDuplicateIDError(char *id, int line_num, FReportErrorFunction report_error, void *report_error_userdata)

static void s_ReportIncorrectNumberOfSequences(int num_expected, int num_found, FReportErrorFunction report_error, void *report_error_userdata)

struct SLineInfoReader SLineInfoReader

TErrorInfoPtr ErrorInfoNew(TErrorInfoPtr list)

struct SAlignFileRaw SAlignRawFileData

TAlignmentFilePtr ReadAlignmentFile2(FReadLineFunction readfunc, void *fileuserdata, FReportErrorFunction errfunc, void *erroruserdata, TSequenceInfoPtr sequence_info, EBool gen_local_ids)

static EBool s_AfrpInitLineData(SAlignRawFilePtr afrp, FReadLineFunction readfunc, void *pfile)

static void s_ReportMissingOrganismInfo(FReportErrorFunction report_error, void *report_error_userdata)

static EBool s_SizeInfoIsEqual(TSizeInfoPtr s1, TSizeInfoPtr s2)

static const size_t kMaxPrintedIntLen

static EBool s_IsBlank(char *str)

static char * s_GetAlignRawSeqIDByOffset(TAlignRawSeqPtr list, int offset)

static void s_ReportBlockLengthError(const char *id, int line_num, int expected_num, int actual_num, FReportErrorFunction report_error, void *report_error_userdata)

static EBool s_CheckNexusCharInfo(const char *str, TSequenceInfoPtr sequence_info, FReportErrorFunction errfunc, void *errdata)

static char * s_GetIdFromString(char *str)

static void s_IntLinkFree(TIntLinkPtr ilp)

static void s_ReportUnusedLine(int line_num_start, int line_num_stop, TLineInfoPtr line_val, FReportErrorFunction errfunc, void *errdata)

static void s_AfrpProcessFastaGap(SAlignRawFilePtr afrp, SLengthListPtr *patterns, EBool *last_line_was_marked_id, char *plinestr, int overall_line_count)

static EBool s_IsAlnFormatString(char *str)

TAlignmentFilePtr ReadAlignmentFileEx2(FReadLineFunction readfunc, void *fileuserdata, FReportErrorFunction errfunc, void *erroruserdata, TSequenceInfoPtr sequence_info, EBool use_nexus_file_info, EBool gen_local_ids)

static TLineInfoReaderPtr s_LineInfoReaderNew(TLineInfoPtr line_list)

static int s_StringNICmp(const char *str1, const char *str2, int cmp_count)

static int s_GetBestCharacterLength(TLineInfoPtr token_list, TIntLinkPtr offset_list, int block_length)

static void s_ReportOrgCommentError(char *linestring, FReportErrorFunction errfunc, void *errdata)

static void s_GetFASTAExpectedNumbers(char *str, SAlignRawFilePtr afrp)

static void s_LengthListFree(SLengthListPtr llp)

static TStringCountPtr s_StringCountNew(TStringCountPtr list)

TSequenceInfoPtr SequenceInfoNew(void)

static void s_FindInterleavedBlocks(SLengthListPtr pattern_list, SAlignRawFilePtr afrp)

static int s_CountCharactersBetweenOffsets(TLineInfoPtr list, int distance, int desired_num_chars)

static TIntLinkPtr GetSegmentOffsetList(TBracketedCommentListPtr comment_list)

static EBool s_DoesBlockHaveIds(SAlignRawFilePtr afrp, TLineInfoPtr first_line, int num_lines_in_block)

static void s_RemoveCommentsFromBlock(TLineInfoPtr first_line, int num_lines_in_block)

TAlignmentFilePtr ReadAlignmentFileEx(FReadLineFunction readfunc, void *fileuserdata, FReportErrorFunction errfunc, void *erroruserdata, TSequenceInfoPtr sequence_info, EBool use_nexus_file_info)

static void s_ReportInconsistentID(char *id, int line_number, FReportErrorFunction report_error, void *report_error_userdata)

static TSizeInfoPtr s_SizeInfoNew(TSizeInfoPtr list)

static SLengthListPtr * s_CreateAnchorPatternForMarkedIDs(SAlignRawFilePtr afrp)

static void s_ReportBadSequenceLength(char *id, int expected_length, int actual_length, FReportErrorFunction report_error, void *report_error_userdata)

static int s_ReportRepeatedBadCharsInSequence(TLineInfoReaderPtr lirp, char *id, const char *reason, FReportErrorFunction report_error, void *report_error_userdata)

static void s_ReportRepeatedId(TStringCountPtr scp, FReportErrorFunction report_error, void *report_error_userdata)

struct SLineInfo SLineInfo

static void s_ProcessBlockLines(SAlignRawFilePtr afrp, TLineInfoPtr lines, int num_lines_in_block, EBool first_block)

static int s_CountSequencesInBracketedComment(TBracketedCommentListPtr comment)

static EBool s_IsASN1(char *linestring)

static int s_LineInfoReaderGetCurrentLineNumber(TLineInfoReaderPtr lirp)

static void s_ReportASN1Error(FReportErrorFunction errfunc, void *errdata)

static TIntLinkPtr s_CreateOffsetList(TSizeInfoPtr list, SLengthListPtr anchorpattern)

static void s_ReportBadCharError(char *id, char bad_char, int num_bad, int offset, int line_number, const char *reason, FReportErrorFunction errfunc, void *errdata)

static void s_RemoveOrganismCommentFromLine(char *string)

static void s_ProcessAlignFileRawForMarkedIDs(SAlignRawFilePtr afrp, EBool gen_local_ids)

static EBool s_AddAlignRawSeqByIndex(TAlignRawSeqPtr list, int index, char *data, int data_line_num, int data_line_offset)

static void s_InsertNewOffsets(TLineInfoPtr token_list, TIntLinkPtr offset_list, int block_length, int best_num_chars, char *alphabet)

static EBool s_DoLengthPatternsMatch(SLengthListPtr llp1, SLengthListPtr llp2)

static int s_StringICmp(const char *str1, const char *str2)

static char * s_GetDeflineFromIdString(char *str)

static TAlignRawSeqPtr s_FindAlignRawSeqById(TAlignRawSeqPtr list, char *id)

static EBool s_IsOrganismComment(TCommentLocPtr clp)

struct SCommentLoc * TCommentLocPtr

static TLineInfoPtr s_RemoveCommentsFromTokens(TLineInfoPtr list)

TAlignmentFilePtr ReadAlignmentFile(FReadLineFunction readfunc, void *fileuserdata, FReportErrorFunction errfunc, void *erroruserdata, TSequenceInfoPtr sequence_info)

static EBool s_IsConsensusLine(char *str)

static SLengthListPtr s_GetBlockPattern(const char *cp)

static TAlignmentFilePtr s_ConvertDataToOutput(SAlignRawFilePtr afrp, TSequenceInfoPtr sip)

static EBool s_FindBadDataCharsInSequence(TAlignRawSeqPtr arsp, TAlignRawSeqPtr master_arsp, TSequenceInfoPtr sip, int num_segments, FReportErrorFunction report_error, void *report_error_userdata)

static EBool s_FoundStopLine(char *linestring)

static SLengthListPtr s_AddLengthList(SLengthListPtr list, SLengthListPtr llp)

struct SAlignFileRaw * SAlignRawFilePtr

struct SIntLink * TIntLinkPtr

static TIntLinkPtr s_AugmentBlockPatternOffsetList(SLengthListPtr pattern_list, TIntLinkPtr offset_list, int block_size)

static int s_GetNumSegmentsInAlignment(TBracketedCommentListPtr comment_list, FReportErrorFunction errfunc, void *errdata)

static TIntLinkPtr s_IntLinkNew(int ival, TIntLinkPtr list)

static SAlignRawFilePtr s_AlignFileRawNew(void)

static EBool s_GetOneNexusSizeComment(const char *str, const char *valname, int *val)

static int s_GetMostPopularSize(TSizeInfoPtr list)

struct SSizeInfo SSizeInfo

static void s_ReportLineLengthError(char *id, TLineInfoPtr lip, int expected_length, FReportErrorFunction report_error, void *report_error_userdata)

static TSizeInfoPtr s_FindMostFrequentlyOccurringTokenLength(TSizeInfoPtr list, int not_this_size)

static void s_ReportInconsistentBlockLine(char *id, int line_number, FReportErrorFunction report_error, void *report_error_userdata)

static SLengthListPtr s_LengthListNew(SLengthListPtr list)

static void s_LineInfoReaderAdvancePastSpace(TLineInfoReaderPtr lirp)

static TIntLinkPtr s_AugmentOffsetList(TIntLinkPtr offset_list, TSizeInfoPtr list, SLengthListPtr anchorpattern)

static EBool s_SkippableNexusComment(char *str)

static EBool s_IsOnlyNumbersAndSpaces(char *str)

static void s_BracketedCommentListAddLine(TBracketedCommentListPtr comment, const char *string, int line_num, int line_offset)

static int s_LineInfoReaderGetCurrentLineOffset(TLineInfoReaderPtr lirp)

static EBool s_BlockIsConsistent(SAlignRawFilePtr afrp, TLineInfoPtr first_line, int num_lines_in_block, EBool has_ids, EBool first_block)

static void s_ReportSegmentedAlignmentError(TIntLinkPtr offset_list, FReportErrorFunction errfunc, void *errdata)

static TSizeInfoPtr s_AddSizeInfo(TSizeInfoPtr list, int size_value)

struct SStringCount * TStringCountPtr

static void s_AlignFileRawFree(SAlignRawFilePtr afrp)

static void s_GetNexusSizeComments(const char *str, EBool *found_ntax, EBool *found_nchar, SAlignRawFilePtr afrp)

static void s_AddLengthRepeat(SLengthListPtr llp, int size_value)

static void s_ReportMissingSequenceData(char *id, FReportErrorFunction report_error, void *report_error_userdata)

static char s_FindNthDataChar(TLineInfoReaderPtr lirp, int pos)

static TCommentLocPtr s_FindOrganismComment(char *string)

struct SCommentLoc SCommentLoc

static char s_GetNexusTypechar(const char *str, const char *val_name)

static EBool s_s_FindBadDataCharsInSequenceList(SAlignRawFilePtr afrp, TSequenceInfoPtr sip)

static void s_AlignRawSeqFree(TAlignRawSeqPtr arsp)

static void s_LineInfoReaderFree(TLineInfoReaderPtr lirp)

static TAlignRawSeqPtr s_AddAlignRawSeqById(TAlignRawSeqPtr list, char *id, char *data, int id_line_num, int data_line_num, int data_line_offset)

static TAlignRawSeqPtr s_AlignRawSeqNew(TAlignRawSeqPtr list)

static TCommentLocPtr s_FindComment(char *string)

struct SLengthList * SLengthListPtr

static char * s_CreateOrderedOrgName(TCommentLocPtr org_clp)

static EBool s_FindUnusedLines(SLengthListPtr pattern_list, SAlignRawFilePtr afrp)

static TLineInfoPtr s_RemoveNexusCommentsFromTokens(TLineInfoPtr list)

static void s_ProcessAlignRawFileByBlockOffsets(SAlignRawFilePtr afrp)

static void s_CommentLocFree(TCommentLocPtr clp)

void ErrorInfoFree(TErrorInfoPtr eip)

static void s_LineInfoFree(TLineInfoPtr lip)

static void s_ExtendAnchorPattern(SLengthListPtr anchorpattern, TSizeInfoPtr line_lengths)

static TStringCountPtr s_AddStringCount(char *string, int line_num, TStringCountPtr list)

static int s_GetMostPopularPatternLength(TIntLinkPtr offset_list)

struct SAlignRawSeq * TAlignRawSeqPtr

static void s_ReadOrgNamesFromText(char *string, int line_num, SAlignRawFilePtr afrp)

static void s_TrimSpace(char **ppline)

static SLengthListPtr s_FindMostPopularPattern(TSizeInfoPtr list)

static char * s_LineInfoMergeAndStripSpaces(TLineInfoPtr list)

static void s_StringLeftShift(char *cp_from, char *cp_to)

struct SLineInfoReader * TLineInfoReaderPtr

struct SBracketedCommentList SBracketedCommentList

static EBool s_ContainsDigits(char *data)

static void s_LineInfoReaderReset(TLineInfoReaderPtr lirp)

struct SBracketedCommentList * TBracketedCommentListPtr

struct SLineInfo * TLineInfoPtr

static void s_ReportBadNumSegError(int line_num, int num_seg, int num_seg_exp, FReportErrorFunction errfunc, void *errdata)

static TLineInfoPtr s_DeleteLineInfos(TLineInfoPtr list)

static EBool s_ReprocessIds(SAlignRawFilePtr afrp)

struct SSizeInfo * TSizeInfoPtr

static TSizeInfoPtr s_AddSizeInfoAppearances(TSizeInfoPtr list, int size_value, int num_appearances)

struct SStringCount SStringCount

static void s_StringCountFree(TStringCountPtr list)

static TCommentLocPtr s_CreateOrderedOrgCommentList(TCommentLocPtr org_clp)

static char * s_TokenizeString(char *str, const char *delimiter, char **last)

static TBracketedCommentListPtr s_BracketedCommentListNew(TBracketedCommentListPtr list, const char *string, int line_num, int line_offset)

#define kMaxPrintedIntLenPlusOne

static void s_SizeInfoFree(TSizeInfoPtr list)

static EBool s_IsTwoNumbersSeparatedBySpace(const char *str)

void SequenceInfoFree(TSequenceInfoPtr sip)

static SAlignRawFilePtr s_ReadAlignFileRaw(FReadLineFunction readfunc, void *userdata, TSequenceInfoPtr sequence_info, EBool use_nexus_file_info, FReportErrorFunction errfunc, void *errdata, EAlignFormat *pformat)

static void s_ReportIncorrectSequenceLength(int len_expected, int len_found, FReportErrorFunction report_error, void *report_error_userdata)

static TSizeInfoPtr s_GetMostPopularSizeInfo(TSizeInfoPtr list)

static EBool s_UpdateNexusCharInfo(const char *str, TSequenceInfoPtr sequence_info)

static void s_RemoveCommentFromLine(char *linestring)

static TLineInfoPtr s_AddLineInfo(TLineInfoPtr list, const char *string, int line_num, int line_offset)

static void s_ReportCharCommentError(const char *expected, char seen, const char *val_name, FReportErrorFunction errfunc, void *errdata)

struct SLengthList SLengthListData

char *(* FReadLineFunction)(void *userdata)

void(* FReportErrorFunction)(TErrorInfoPtr err_ptr, void *userdata)

struct SSequenceInfo * TSequenceInfoPtr

struct SErrorInfo * TErrorInfoPtr

struct SAlignmentFile * TAlignmentFilePtr

static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)

static DLIST_TYPE *DLIST_NAME() last(DLIST_LIST_TYPE *list)

static DLIST_TYPE *DLIST_NAME() prev(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

static DLIST_TYPE *DLIST_NAME() next(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

static unsigned int line_num

static const char * expected[]

static const char * str(char *buf, int n)

The blob sat and sat key Both must be positive integers</td > n< td > Non empty string The interpretation of the blob id depends on a processor Cassandra n processor expects the following format

int strncmp(const char *str1, const char *str2, size_t count)

int strcmp(const char *str1, const char *str2)

static const char delimiter[]

static SLJIT_INLINE sljit_ins msg(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

int expected_num_sequence

TAlignRawSeqPtr sequences

FReportErrorFunction report_error

int expected_sequence_len

void * report_error_userdata

TLineInfoPtr sequence_data

struct SAlignRawSeq * next

struct SLengthList * next

TSizeInfoPtr lengthrepeats

struct SStringCount * next

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4