bool ButtonArray::_get(const StringName& p_name,Variant &r_ret) const {
String n=String(p_name);
if (n.begins_with("button/")) {
String what = n.get_slicec('/',1);
if (what=="count") {
r_ret=buttons.size();
} else if (what=="align") {
r_ret=get_align();
} else if (what=="selected") {
r_ret=get_selected();
} else if (what == "min_button_size") {
r_ret = min_button_size;
} else {
int idx=what.to_int();
ERR_FAIL_INDEX_V(idx,buttons.size(),false);
String f = n.get_slicec('/',2);
if (f=="text")
r_ret=buttons[idx].text;
else if (f=="tooltip")
r_ret=buttons[idx].tooltip;
else if (f=="icon")
r_ret=buttons[idx].icon;
else
return false;
}
return true;
}
return false;
}
bool unit::is_ally(const unit_ptr &u) const
{
if (!u)
return false;
if (get_align() == align_neutral || u->get_align() == align_neutral)
return true;
if (u->get_align() == get_align())
return true;
if (u->get_align() == align_ally || get_align() == align_ally)
return false;
return true;
}
//------------------------------------------------------------------------------
Elf_Half
add_section_index( Elf_Half sec_index, Elf_Xword addr_align )
{
sections.push_back( sec_index );
if ( addr_align > get_align() ) {
set_align( addr_align );
}
return (Elf_Half)sections.size();
}
void fix_overlapping_pieces(const char *aseq, const char *bseq,
Local_Overlap *O,int piece0, int piece1){
PAIRALIGN *pair_align1,*pair_align2;
int offseta1,offsetb1,offseta2,offsetb2;
int bestend1a,bestend1b,bestbeg2a,bestbeg2b;
int into1,into2,bestinto2=0;
int errs1,errs2,minerrs;
assert(O->chain[piece0].piece.aepos>=O->chain[piece1].piece.abpos||
O->chain[piece0].piece.bepos>=O->chain[piece1].piece.bbpos);
assert(O->chain[piece0].piece.aepos<=O->chain[piece1].piece.aepos);
assert(O->chain[piece0].piece.bepos<=O->chain[piece1].piece.bepos);
/* create alignments for the two segments */
pair_align1=get_align(aseq,bseq,O,piece0,0);
pair_align2=get_align(aseq,bseq,O,piece1,1);
if(pair_align1 == NULL || pair_align2 == NULL){
fprintf(stderr,"EXCEPTION pair_align1=%p pair_align2=%p\n", pair_align1, pair_align2);
fprintf(stderr,"EXCEPTION while fixing gap(%d,%d) (%d,%d)---(%d,%d) vs. gap(%d,%d) (%d,%d)---(%d,%d)\n",
O->chain[piece0].agap, O->chain[piece0].bgap,
O->chain[piece0].piece.abpos,O->chain[piece0].piece.bbpos,
O->chain[piece0].piece.aepos,O->chain[piece0].piece.bepos,
O->chain[piece1].agap, O->chain[piece1].bgap,
O->chain[piece1].piece.abpos,O->chain[piece1].piece.bbpos,
O->chain[piece1].piece.aepos,O->chain[piece1].piece.bepos);
}
if(pair_align1 == NULL){
fprintf(stderr,"EXCEPTION Fixing by pseudo-deleting piece0.\n");
O->chain[piece0].agap=0;
O->chain[piece0].bgap=0;
if(piece0>0){
O->chain[piece0].piece.abpos=O->chain[piece0-1].piece.aepos;
O->chain[piece0].piece.aepos=O->chain[piece0-1].piece.aepos;
O->chain[piece0].piece.bbpos=O->chain[piece0-1].piece.bepos;
O->chain[piece0].piece.bepos=O->chain[piece0-1].piece.bepos;
} else {
O->chain[piece0].piece.abpos=0;
O->chain[piece0].piece.aepos=0;
O->chain[piece0].piece.bbpos=0;
O->chain[piece0].piece.bepos=0;
}
O->chain[piece1].agap = O->chain[piece1].piece.abpos - O->chain[piece0].piece.aepos;
O->chain[piece1].bgap = O->chain[piece1].piece.bbpos - O->chain[piece0].piece.bepos;
return;
}
if(pair_align2 == NULL){
fprintf(stderr,"EXCEPTION Fixing by pseudo-deleting piece1.\n");
O->chain[piece1].agap=0;
O->chain[piece1].bgap=0;
O->chain[piece1].piece.abpos = O->chain[piece0].piece.aepos;
O->chain[piece1].piece.aepos = O->chain[piece0].piece.aepos;
O->chain[piece1].piece.bbpos = O->chain[piece0].piece.bepos;
O->chain[piece1].piece.bepos = O->chain[piece0].piece.bepos;
if(piece1+1<=O->num_pieces){
O->chain[piece1+1].agap=O->chain[piece1+1].piece.abpos - O->chain[piece0].piece.aepos;
O->chain[piece1+1].bgap=O->chain[piece1+1].piece.bbpos - O->chain[piece0].piece.bepos;
}
return;
}
/* if, in finding the alignments, we shift the ends of the
alignment of the first segment to after the starts of the
alignment of the second segment, then the overlap has been
resolved, so we do nothing more */
if(!(O->chain[piece0].piece.aepos>=O->chain[piece1].piece.abpos||
O->chain[piece0].piece.bepos>=O->chain[piece1].piece.bbpos)){
return;
}
/* if, in finding the alignments, we shift the end of the
alignment of the second segment to before the start of the
alignment of the first segment, then the second is contained
in the first and we need to do something exceptional;
the most heuristic, but consistent with the practice elsewhere
in the local overlapper, is to pseudo-delete the second segment */
if(!(O->chain[piece0].piece.aepos<=O->chain[piece1].piece.aepos)||
!(O->chain[piece0].piece.bepos<=O->chain[piece1].piece.bepos)){
O->chain[piece1].agap=0;
O->chain[piece1].bgap=0;
O->chain[piece1].piece.abpos=O->chain[piece0].piece.aepos;
O->chain[piece1].piece.aepos=O->chain[piece0].piece.aepos;
O->chain[piece1].piece.bbpos=O->chain[piece0].piece.bepos;
O->chain[piece1].piece.bepos=O->chain[piece0].piece.bepos;
if(piece1+1<=O->num_pieces){
O->chain[piece1+1].agap=O->chain[piece1+1].piece.abpos-
O->chain[piece0].piece.aepos;
O->chain[piece1+1].bgap=O->chain[piece1+1].piece.bbpos-
O->chain[piece0].piece.bepos;
}
return;
}
/* if, in finding the alignments, we shift the start of the
alignment of the first segment to after the start of the
alignment of the second segment, then the first is contained
in the second and we need to do something exceptional;
the most heuristic, but consistent with the practice elsewhere
in the local overlapper, is to pseudo-delete the first segment */
if(O->chain[piece0].piece.abpos>O->chain[piece1].piece.abpos||
O->chain[piece0].piece.bbpos>O->chain[piece1].piece.bbpos){
O->chain[piece0].agap=0;
O->chain[piece0].bgap=0;
if(piece0>0){
O->chain[piece0].piece.abpos=O->chain[piece0-1].piece.aepos;
O->chain[piece0].piece.aepos=O->chain[piece0-1].piece.aepos;
O->chain[piece0].piece.bbpos=O->chain[piece0-1].piece.bepos;
O->chain[piece0].piece.bepos=O->chain[piece0-1].piece.bepos;
} else {
O->chain[piece0].piece.abpos=0;
O->chain[piece0].piece.aepos=0;
O->chain[piece0].piece.bbpos=0;
O->chain[piece0].piece.bepos=0;
}
O->chain[piece1].agap=O->chain[piece1].piece.abpos-
O->chain[piece0].piece.aepos;
O->chain[piece1].bgap=O->chain[piece1].piece.bbpos-
O->chain[piece0].piece.bepos;
return;
}
/* find start of region for evaluation in first alignment */
/* when done,
offseta1 and offsetb1 should be the offsets into the sequences
such that they correspond to a column in the alignment of the
first segment and that column contains the first possible
overlap with the second segment */
offseta1=O->chain[piece0].piece.abpos;
offsetb1=O->chain[piece0].piece.bbpos;
into1=0;
while(offseta1<O->chain[piece1].piece.abpos&&
offsetb1<O->chain[piece1].piece.bbpos){
assert(pair_align1->aseg[into1]!='\0');
assert(pair_align1->bseg[into1]!='\0');
if(pair_align1->aseg[into1]!='-')offseta1++;
if(pair_align1->bseg[into1]!='-')offsetb1++;
into1++;
}
// if(pair_align1->aseg[into1-1]!='-')offseta1--;
// if(pair_align1->bseg[into1-1]!='-')offsetb1--;
/* count mismatches in the second alignment */
into2=0;
errs2=0;
while(pair_align2->aseg[into2]!='\0'){
assert(pair_align2->bseg[into2]!='\0');
if(pair_align2->aseg[into2]!=pair_align2->bseg[into2]){
errs2++;
}
into2++;
}
/* initialize solution variables and auxiliaries */
into2=0;
errs1 = (pair_align1->aseg[into1]!=pair_align1->bseg[into1] ? 1 : 0);
minerrs=errs2;
offseta2=O->chain[piece1].piece.abpos;
offsetb2=O->chain[piece1].piece.bbpos;
bestend1a=offseta1 - (pair_align1->aseg[into1-1]!='-' ? 1 : 0);
bestend1b=offsetb1 - (pair_align1->bseg[into1-1]!='-' ? 1 : 0);
bestbeg2a=offseta2;
bestbeg2b=offsetb2;
/* while there is potential overlap still to come ... */
while(pair_align1->aseg[into1]!='\0'&&pair_align2->aseg[into2]!='\0'){
// Once, we did the following assert, assuming that the alignment
// of pair_align2 would not run out before pair_align1, since otherwise
// there would be a containment or some such that shouldn't happen;
// But, as luck would have it, alignment trimming quirks etc can
// make it happen. So ... no more assert
//
// assert(pair_align2->aseg[into2]!='\0');
/* while a position in the second segment is no greater than
the position in the first segment,
check for mismatch in second segment,
counting errors,
incrementing the sequence position counters as appropriate;
advance the second segment
position */
while(offseta1>=offseta2||offsetb1>=offsetb2){
errs2-= (pair_align2->aseg[into2]!=pair_align2->bseg[into2] ? 1 : 0);
offseta2+= ( pair_align2->aseg[into2]!='-' ? 1 : 0 );
offsetb2+= ( pair_align2->bseg[into2]!='-' ? 1 : 0 );
into2++;
if(pair_align2->aseg[into2]=='\0'){
break;
}
// assert(pair_align2->aseg[into2]!='\0');
// assert(pair_align2->bseg[into2]!='\0');
}
if(errs1+errs2<=minerrs&&
pair_align1->aseg[into1]==pair_align1->bseg[into1]){
minerrs=errs1+errs2;
bestend1a=offseta1 /* -(pair_align1->aseg[into1-1]!='-' ? 1 : 0 )*/;
bestend1b=offsetb1 /* -(pair_align1->bseg[into1-1]!='-' ? 1 : 0 )*/;
bestbeg2a=offseta2;
bestbeg2b=offsetb2;
bestinto2=into2;
}
/* while the positions in the first segment are no greater than
the positions in the second segment,
check for mismatch in first segment,
counting errors,
incrementing the sequence position counters as appropriate;
advance the first segment
position */
while(offseta1<offseta2&&offsetb1<offsetb2){
offseta1+= ( pair_align1->aseg[into1]!='-' ? 1 : 0 );
offsetb1+= ( pair_align1->bseg[into1]!='-' ? 1 : 0 );
into1++;
errs1+= (pair_align1->aseg[into1]!=pair_align1->bseg[into1] ? 1 : 0);
if(pair_align1->aseg[into1]=='\0'){
break;
}
}
}
if(bestend1a<O->chain[piece0].piece.aepos)
bestend1a++;
if(bestend1b<O->chain[piece0].piece.bepos)
bestend1b++;
O->chain[piece0].piece.aepos=bestend1a;
O->chain[piece0].piece.bepos=bestend1b;
O->chain[piece1].piece.abpos=bestbeg2a;
O->chain[piece1].piece.bbpos=bestbeg2b;
O->chain[piece1].agap=bestbeg2a-bestend1a;
O->chain[piece1].bgap=bestbeg2b-bestend1b;
assert(O->chain[piece1].agap>=0);
assert(O->chain[piece1].bgap>=0);
assert(O->chain[piece1].agap==0||O->chain[piece1].bgap==0);
// now, adjust the beginning of the second piece to skip any mismatches
while(pair_align2->aseg[bestinto2]!=pair_align2->bseg[bestinto2]&&
pair_align2->aseg[bestinto2]!='\0'){
bestbeg2a += ( pair_align2->aseg[bestinto2]!='-' ? 1 : 0 );
bestbeg2b += ( pair_align2->bseg[bestinto2]!='-' ? 1 : 0 );
bestinto2++;
}
O->chain[piece1].piece.abpos=bestbeg2a;
O->chain[piece1].piece.bbpos=bestbeg2b;
O->chain[piece1].agap=bestbeg2a-bestend1a;
O->chain[piece1].bgap=bestbeg2b-bestend1b;
assert(O->chain[piece1].piece.abpos<=O->chain[piece1].piece.aepos);
assert(O->chain[piece1].piece.bbpos<=O->chain[piece1].piece.bepos);
}
struct table *parse_table(unsigned char *html, unsigned char *eof, unsigned char **end, struct rgb *bgcolor, int sh, struct s_e **bad_html, int *bhp)
{
int qqq;
struct table *t;
struct table_cell *cell;
unsigned char *t_name, *t_attr, *en;
int t_namelen;
int x = 0, y = -1;
int p = 0;
unsigned char *lbhp = NULL;
int l_al = AL_LEFT;
int l_val = VAL_MIDDLE;
int csp, rsp;
int group = 0;
int i, j, k;
struct rgb l_col;
int c_al = AL_TR, c_val = VAL_TR, c_width = W_AUTO, c_span = 0;
memcpy(&l_col, bgcolor, sizeof(struct rgb));
*end = html;
if (bad_html) {
*bad_html = DUMMY;
*bhp = 0;
}
if (!(t = new_table())) return NULL;
se:
en = html;
see:
html = en;
if (bad_html && !p && !lbhp) {
if (!(*bhp & (ALLOC_GR-1))) {
if ((unsigned)*bhp > MAXINT / sizeof(struct s_e) - ALLOC_GR) overalloc();
*bad_html = mem_realloc(*bad_html, (*bhp + ALLOC_GR) * sizeof(struct s_e));
}
lbhp = (*bad_html)[(*bhp)++].s = html;
}
while (html < eof && *html != '<') html++;
if (html >= eof) {
if (p) CELL(t, x, y)->end = html;
if (lbhp) (*bad_html)[*bhp-1].e = html;
goto scan_done;
}
if (html + 2 <= eof && (html[1] == '!' || html[1] == '?')) {
html = skip_comment(html, eof);
goto se;
}
if (parse_element(html, eof, &t_name, &t_namelen, &t_attr, &en)) {
html++;
goto se;
}
if (t_namelen == 5 && !casecmp(t_name, "TABLE", 5)) {
en = skip_table(en, eof);
goto see;
}
if (t_namelen == 6 && !casecmp(t_name, "/TABLE", 6)) {
if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1);
if (p) CELL(t, x, y)->end = html;
if (lbhp) (*bad_html)[*bhp-1].e = html;
goto scan_done;
}
if (t_namelen == 8 && !casecmp(t_name, "COLGROUP", 8)) {
if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1);
if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL;
c_al = AL_TR;
c_val = VAL_TR;
c_width = W_AUTO;
get_align(t_attr, &c_al);
get_valign(t_attr, &c_val);
get_c_width(t_attr, &c_width, sh);
if ((c_span = get_num(t_attr, "span")) == -1) c_span = 1;
goto see;
}
if (t_namelen == 9 && !casecmp(t_name, "/COLGROUP", 9)) {
if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1);
if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL;
c_span = 0;
c_al = AL_TR;
c_val = VAL_TR;
c_width = W_AUTO;
goto see;
}
if (t_namelen == 3 && !casecmp(t_name, "COL", 3)) {
int sp, wi, al, val;
if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL;
if ((sp = get_num(t_attr, "span")) == -1) sp = 1;
wi = c_width;
al = c_al;
val = c_val;
get_align(t_attr, &al);
get_valign(t_attr, &val);
get_c_width(t_attr, &wi, sh);
new_columns(t, sp, wi, al, val, !!c_span);
c_span = 0;
goto see;
}
if (t_namelen == 3 && (!casecmp(t_name, "/TR", 3) || !casecmp(t_name, "/TD", 3) || !casecmp(t_name, "/TH", 3))) {
if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1);
if (p) CELL(t, x, y)->end = html, p = 0;
if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL;
}
if (t_namelen == 2 && !casecmp(t_name, "TR", 2)) {
if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1);
if (p) CELL(t, x, y)->end = html, p = 0;
if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL;
if (group) group--;
l_al = AL_LEFT;
l_val = VAL_MIDDLE;
memcpy(&l_col, bgcolor, sizeof(struct rgb));
get_align(t_attr, &l_al);
get_valign(t_attr, &l_val);
get_bgcolor(t_attr, &l_col);
y++, x = 0;
goto see;
}
if (t_namelen == 5 && ((!casecmp(t_name, "THEAD", 5)) || (!casecmp(t_name, "TBODY", 5)) || (!casecmp(t_name, "TFOOT", 5)))) {
if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1);
if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL;
group = 2;
}
if (t_namelen != 2 || (casecmp(t_name, "TD", 2) && casecmp(t_name, "TH", 2))) goto see;
if (c_span) new_columns(t, c_span, c_width, c_al, c_val, 1);
if (lbhp) (*bad_html)[*bhp-1].e = html, lbhp = NULL;
if (p) CELL(t, x, y)->end = html, p = 0;
if (y == -1) y = 0, x = 0;
nc:
cell = new_cell(t, x, y);
if (cell->used) {
if (cell->colspan == -1) goto see;
x++;
goto nc;
}
cell->mx = x;
cell->my = y;
cell->used = 1;
cell->start = en;
p = 1;
cell->align = l_al;
cell->valign = l_val;
if ((cell->b = upcase(t_name[1]) == 'H')) cell->align = AL_CENTER;
if (group == 1) cell->group = 1;
if (x < t->c) {
if (t->cols[x].align != AL_TR) cell->align = t->cols[x].align;
if (t->cols[x].valign != VAL_TR) cell->valign = t->cols[x].valign;
}
memcpy(&cell->bgcolor, &l_col, sizeof(struct rgb));
get_align(t_attr, &cell->align);
get_valign(t_attr, &cell->valign);
get_bgcolor(t_attr, &cell->bgcolor);
if ((csp = get_num(t_attr, "colspan")) == -1) csp = 1;
if (!csp) csp = -1;
if ((rsp = get_num(t_attr, "rowspan")) == -1) rsp = 1;
if (!rsp) rsp = -1;
if (csp >= 0 && rsp >= 0 && csp * rsp > 100000) {
if (csp > 10) csp = -1;
if (rsp > 10) rsp = -1;
}
cell->colspan = csp;
cell->rowspan = rsp;
if (csp == 1) {
int w = W_AUTO;
get_c_width(t_attr, &w, sh);
if (w != W_AUTO) set_td_width(t, x, w, 0);
}
qqq = t->x;
for (i = 1; csp != -1 ? i < csp : x + i < qqq; i++) {
struct table_cell *sc = new_cell(t, x + i, y);
if (sc->used) {
csp = i;
for (k = 0; k < i; k++) CELL(t, x + k, y)->colspan = csp;
break;
}
sc->used = sc->spanned = 1;
sc->rowspan = rsp;
sc->colspan = csp;
sc->mx = x;
sc->my = y;
}
qqq = t->y;
for (j = 1; rsp != -1 ? j < rsp : y + j < qqq; j++) {
for (k = 0; k < i; k++) {
struct table_cell *sc = new_cell(t, x + k, y + j);
if (sc->used) {
int l, m;
if (sc->mx == x && sc->my == y) continue;
/*internal("boo");*/
for (l = 0; l < k; l++) memset(CELL(t, x + l, y + j), 0, sizeof(struct table_cell));
rsp = j;
for (l = 0; l < i; l++) for (m = 0; m < j; m++) CELL(t, x + l, y + m)->rowspan = j;
goto brk;
}
sc->used = sc->spanned = 1;
sc->rowspan = rsp;
sc->colspan = csp;
sc->mx = x;
sc->my = y;
}
}
brk:
goto see;
scan_done:
*end = html;
for (x = 0; x < t->x; x++) for (y = 0; y < t->y; y++) {
struct table_cell *c = CELL(t, x, y);
if (!c->spanned) {
if (c->colspan == -1) c->colspan = t->x - x;
if (c->rowspan == -1) c->rowspan = t->y - y;
}
}
if ((unsigned)t->y > MAXINT / sizeof(int)) overalloc();
t->r_heights = mem_alloc(t->y * sizeof(int));
memset(t->r_heights, 0, t->y * sizeof(int));
for (x = 0; x < t->c; x++) if (t->cols[x].width != W_AUTO) set_td_width(t, x, t->cols[x].width, 1);
set_td_width(t, t->x, W_AUTO, 0);
return t;
}
