void center_tbox(void *list, int c)
{
int x1=0,y1=0,x2=79,y2=25;
int h;
if (item_type(list)==L_CONS_CELL)
h=list_length(list);
else h=1;
int y=(y1+y2)/2-h/2+1;
box(x1,(y1+y2)/2-h/2,x2,(y1+y2)/2-h/2+h+1,c);
bar(x1+1,y,x2-1,(y1+y2)/2-h/2+h+1-1,' ',c);
if (item_type(list)==L_CONS_CELL)
{
while (list)
{
char *s=lstring_value(CAR(list));
put_string((x1+x2)/2-strlen(s)/2,y++,s,c);
list=CDR(list);
}
} else
{
char *s=lstring_value(list);
put_string((x1+x2)/2-strlen(s)/2,y++,s,c);
}
}
int CacheList::reg_object(char const *filename, LObject *object, int type,
int rm_dups) {
// See if we got a object with a filename included. Otherwise,
// it's a string.
if (item_type(object) == L_CONS_CELL) {
filename = lstring_value(lcar(object));
object = lcdr(object);
}
return reg(filename, lstring_value(object), type, rm_dups);
}
char *men_str(void *arg)
{
switch (item_type(arg))
{
case L_STRING :
{ return lstring_value(arg); } break;
case L_CONS_CELL :
{ return lstring_value(CAR(arg)); } break;
default :
{
lprint(arg);
dprintf(" is not a valid menu option\n");
exit(0);
}
}
return NULL;
}
void *show_yes_no(void *t, void *msg, void *y, void *n)
{
p_ref r1(t),r2(msg),r3(y),r4(n);
t=eval(t); msg=eval(msg); y=eval(y); n=eval(n);
int c;
char *yes=lstring_value(y);
char *no=lstring_value(n);
do
{
dprintf("\n\n\n\n\n%s\n\n",lstring_value(t));
void *v=msg;
if (item_type(v)==L_CONS_CELL)
while (v) { dprintf("** %s\n",lstring_value(CAR(v))); v=CDR(v); }
else dprintf("** %s\n",lstring_value(v));
char msg[100];
fgets(msg,100,stdin);
c=msg[0];
} while (toupper(c)!=toupper(yes[0]) && toupper(c)!=toupper(no[0]));
if (toupper(c)==toupper(yes[0]))
return true_symbol;
else return NULL;
}
/**
* Return item_type for index:
* 0 -> node, 1 -> way, 2 -> relation
*/
inline item_type nwr_index_to_item_type(unsigned int i) noexcept {
assert(i <= 2);
return item_type(i+1);
}
QVariant GsTLGridPropertyGroup::item_data(int column) const{
if(column == 0) return QString(name_.c_str());
else if (column == 1) return item_type();
else return QVariant();
}
int menu(void *args, JCFont *font) // reurns -1 on esc
{
main_menu();
char *title=NULL;
if (!NILP(CAR(args)))
title=lstring_value(CAR(args));
Cell *def=lcar(lcdr(lcdr(args)));
args=CAR(CDR(args));
int options=list_length(args);
int mh=(font->height()+1)*options+10,maxw=0;
Cell *c=(Cell *)args;
for (;!NILP(c);c=CDR(c))
{
if (strlen(men_str(CAR(c)))>maxw)
maxw=strlen(men_str(CAR(c)));
}
int mw=(font->width())*maxw+20;
int mx=screen->width()/2-mw/2,
my=screen->height()/2-mh/2;
screen->add_dirty(mx,my,mx+mw-1,my+mh-1);
if (title)
{
int tl=strlen(title)*font->width();
int tx=screen->width()/2-tl/2;
dark_wiget(tx-2,my-font->height()-4,tx+tl+2,my-2,eh->medium_color(),eh->dark_color(),180);
font->put_string(screen,tx+1,my-font->height()-2,title,eh->bright_color());
}
dark_wiget(mx,my,mx+mw-1,my+mh-1,eh->medium_color(),eh->dark_color(),200);
int y=my+5;
for (c=(Cell *)args;!NILP(c);c=CDR(c))
{
char *ms=men_str(CAR(c));
font->put_string(screen,mx+10+1,y+1,ms,eh->black());
font->put_string(screen,mx+10,y,ms,eh->bright_color());
y+=font->height()+1;
}
eh->flush_screen();
event ev;
int choice=0,done=0;
int bh=font->height()+3;
image *save=new image(mw-2,bh);
int color=128,cdir=50;
time_marker *last_color_time=NULL;
if (!NILP(def))
choice=lnumber_value(def);
do
{
eh->flush_screen();
if (eh->event_waiting())
{
eh->get_event(ev);
if (ev.type==EV_KEY)
{
switch (ev.key)
{
case JK_ESC :
{ choice=-1; done=1; } break;
case JK_ENTER :
{ done=1; } break;
case JK_DOWN :
{ if (choice<options-1)
choice++;
else choice=0;
} break;
case JK_UP :
{
if (choice>0)
choice--;
else choice=options-1;
} break;
}
} else if (ev.type==EV_MOUSE_BUTTON && ev.mouse_button)
{
if (ev.mouse_move.x>mx && ev.mouse_move.x<mx+mw && ev.mouse_move.y>my &&
ev.mouse_move.y<my+mh)
{
int msel=(ev.mouse_move.y-my)/(font->height()+1);
if (msel>=options) msel=options-1;
if (msel==choice) // clicked on already selected item, return it
done=1;
else choice=msel; // selects an item
}
}
}
time_marker cur_time;
if (!last_color_time || (int)(cur_time.diff_time(last_color_time)*1000)>120)
{
if (last_color_time)
delete last_color_time;
last_color_time=new time_marker;
int by1=(font->height()+1)*choice+my+5-2;
int by2=by1+bh-1;
screen->put_part(save,0,0,mx+1,by1,mx+mw-2,by2);
tint_area(mx+1,by1,mx+mw-2,by2,63,63,63,color);
char *cur=men_str(nth(choice,args));
font->put_string(screen,mx+10+1,by1+3,cur,eh->black());
font->put_string(screen,mx+10,by1+2,cur,eh->bright_color());
screen->rectangle(mx+1,by1,mx+mw-2,by2,eh->bright_color());
color+=cdir;
if (color<12 || color>256)
{
cdir=-cdir;
color+=cdir;
}
eh->flush_screen();
save->put_image(screen,mx+1,by1);
} else milli_wait(10);
} while (!done);
if (last_color_time)
delete last_color_time;
delete save;
the_game->draw(the_game->state==SCENE_STATE);
if (choice!=-1)
{
void *val=nth(choice,args);
if (item_type(val)==L_CONS_CELL) // is there another value that the user want us to return?
return lnumber_value(lcdr(val));
}
return choice;
}
/* Main function to calculate items sequence */
int DpsCalcBoolItems(DPS_AGENT *query, DPS_RESULT *Res) {
DPS_BOOLSTACK *s = DpsBoolStackInit(NULL);
DPS_STACK_ITEM *items = Res->items, *res;
DPS_WIDEWORD Word;
size_t nitems = Res->nitems;
size_t i, j;
int first_time = (Res->WWList.nwords == 0);
if (s == NULL) return DPS_STACK_ERR;
if (nitems == 0) {
Res->CoordList.Coords = Res->items[0].pbegin;
Res->items[0].pbegin = NULL;
Res->items[0].count = 0;
/* Res->CoordList.ncoords = Res->items[0]->count;*/
DpsBoolStackFree(s);
return DPS_OK;
}
for (i = 0; i < nitems; i++) {
if (items[i].cmd != DPS_STACK_WORD) continue;
if ((items[i].pbegin == NULL) && ((items[i].origin & DPS_WORD_ORIGIN_STOP) == 0)) {
for(j = 0; j < i; j++)
if (items[j].crcword == items[i].crcword) break;
if (j < i) {
items[i].count = items[j].count;
items[i].pbegin = (DPS_URL_CRD_DB*)DpsMalloc((items[j].count + 1) * sizeof(DPS_URL_CRD_DB));
if (items[i].pbegin == NULL) {
DpsLog(query, DPS_LOG_ERROR, "Can't alloc %d bytes %s:%d", (items[j].count + 1) * sizeof(DPS_URL_CRD_DB), __FILE__, __LINE__);
DpsBoolStackFree(s);
return DPS_STACK_ERR;
}
{
register size_t z;
for (z = 0; z < items[i].count; z++) {
items[i].pbegin[z] = items[j].pbegin[z];
items[i].pbegin[z].coord &= 0xFFFFFF00;
items[i].pbegin[z].coord += (items[i].wordnum & 0xFF);
}
}
}
}
if (first_time) {
Word.order = items[i].order;
Word.count = items[i].count;
Word.crcword = items[i].crcword;
Word.word = items[i].word;
Word.uword = items[i].uword;
Word.origin = items[i].origin;
DpsWideWordListAdd(&Res->WWList, &Word, DPS_WWL_LOOSE);
}
}
#ifdef DEBUG_BOOL
DpsLog(query, DPS_LOG_EXTRA, "--------");
for(i=0;i<nitems;i++){
DpsLog(query, DPS_LOG_EXTRA, "[%d].%d %c : %d -- %s",
i, items[i].wordnum, item_type(items[i].cmd), items[i].count, (items[i].word == NULL) ? "<NULL>" : items[i].word);
}
DpsLog(query, DPS_LOG_EXTRA, "--------");
#endif
for(i=0;i<nitems;i++){
int c;
#ifdef DEBUG_BOOL
DpsLog(query, DPS_LOG_EXTRA,
".[%d].%d %c : %d -- %s, (order_origin:%d)", i, items[i].wordnum, item_type(items[i].cmd), items[i].count, (items[i].word == NULL) ? "<NULL>" : items[i].word, items[i].order_origin);
#endif
switch(c=items[i].cmd){
case DPS_STACK_RIGHT:
/* Perform till LEFT bracket */
while((TOPCMD(s) != DPS_STACK_LEFT) && (TOPCMD(s) != DPS_STACK_BOT))
if (DPS_OK != perform(query, Res, s, POPCMD(s))) {
DpsBoolStackFree(s);
return DPS_STACK_ERR;
}
/* Pop LEFT bracket itself */
if(TOPCMD(s) == DPS_STACK_LEFT)
POPCMD(s);
break;
case DPS_STACK_OR:
case DPS_STACK_AND:
case DPS_STACK_NEAR:
case DPS_STACK_ANYWORD:
if (s->nastack > 1)
while(c <= TOPCMD(s)) {
if (DPS_OK != perform(query, Res, s, POPCMD(s))) {
DpsBoolStackFree(s);
return DPS_STACK_ERR;
}
}
/* IMPORTANT! No break here! That's OK*/
/* Так надо ! */
case DPS_STACK_LEFT:
case DPS_STACK_PHRASE_LEFT:
case DPS_STACK_NOT:
if (PUSHCMD(s,c) != DPS_OK) {
DpsBoolStackFree(s);
return DPS_STACK_ERR;
}
break;
case DPS_STACK_PHRASE_RIGHT:
/* perform till RIGHT phrase quote */
while((TOPCMD(s) != DPS_STACK_PHRASE_LEFT) && (TOPCMD(s) != DPS_STACK_BOT))
if (DPS_OK != perform(query, Res, s, POPCMD(s))) {
DpsBoolStackFree(s);
return DPS_STACK_ERR;
}
if (TOPCMD(s) == DPS_STACK_PHRASE_LEFT) perform(query, Res, s, POPCMD(s));
#ifdef DEBUG_BOOL
DpsLog(query, DPS_LOG_EXTRA, "[%d] %c", i, item_type(items[i].cmd));
#endif
break;
case DPS_STACK_WORD:
items[i].order_from = items[i].order_to = items[i].order;
default:
if (DPS_OK != PUSHARG(s, &items[i])) {
DpsBoolStackFree(s);
return DPS_STACK_ERR;
}
items[i].pbegin = items[i].plast = NULL; /*items[i].word = NULL; items[i].uword = NULL;*/
/* items[i].count = 0;*/
/* DpsStackItemFree(&items[i]);*/
/* if (DPS_OK != PUSHARG(s, (count[items[i].order]) ? 1UL : 0UL)) {
DpsBoolStackFree(s);
return DPS_STACK_ERR;
}*/
break;
}
}
while(TOPCMD(s) != DPS_STACK_BOT) {
if (DPS_OK != perform(query, Res, s, POPCMD(s))) {
DpsBoolStackFree(s);
return DPS_STACK_ERR;
}
}
res = POPARG(s);
if (res != NULL) {
Res->CoordList.Coords = res->pbegin;
Res->CoordList.ncoords = res->count;
res->pbegin = res->plast = NULL;
/* res->count = 0;*/
DpsStackItemFree(res);
}
#ifdef DEBUG_BOOL
DpsLog(query, DPS_LOG_EXTRA, "result: %x", res);
#endif
DpsBoolStackFree(s);
return DPS_OK;
}
int DpsAddStackItem(DPS_AGENT *query, DPS_RESULT *Res, DPS_PREPARE_STATE *state, char *word, dpsunicode_t *uword) {
int origin;
size_t i;
size_t wlen = (uword == NULL) ? 0 : DpsUniLen(uword);
dpshash32_t crcword = (word == NULL) ? 0 : DpsStrHash32(word);
#ifdef DEBUG_BOOL
DpsLog(query, DPS_LOG_EXTRA, "0[%d].%x %c -- %s [%x] .secno:%d\n", state->order, state->origin, item_type(state->cmd),
(word == NULL) ? "<NULL>" : word, crcword, state->secno[state->p_secno]);
#endif
if((uword != NULL) && ( DpsStopListFind(&query->Conf->StopWords, uword, state->qlang) ||
(query->WordParam.min_word_len > wlen) ||
(query->WordParam.max_word_len < wlen)) ) {
origin = state->origin | DPS_WORD_ORIGIN_STOP;
} else {
origin = state->origin;
}
if (state->cmd == DPS_STACK_WORD && !(origin & DPS_WORD_ORIGIN_QUERY)) {
for (i = 0; i < Res->nitems; i++) {
if ((Res->items[i].order == state->order) && (Res->items[i].crcword == crcword)) return DPS_OK;
}
}
if (Res->nitems >= Res->mitems - 2) {
Res->mitems += DPS_MAXSTACK;
Res->items = (DPS_STACK_ITEM*)DpsRealloc(Res->items, Res->mitems * sizeof(DPS_STACK_ITEM));
if (Res->items == NULL) {
DpsLog(query, DPS_LOG_ERROR, "Can't alloc %d bytes for %d mitems", Res->mitems * sizeof(DPS_STACK_ITEM), Res->mitems);
return DPS_ERROR;
}
}
if (Res->nitems > 0) {
if (state->cmd == DPS_STACK_OR || state->cmd == DPS_STACK_AND || state->cmd == DPS_STACK_NEAR || state->cmd == DPS_STACK_ANYWORD) {
if (Res->items[Res->nitems-1].cmd == DPS_STACK_AND || Res->items[Res->nitems-1].cmd == DPS_STACK_OR
|| Res->items[Res->nitems-1].cmd == DPS_STACK_NEAR || Res->items[Res->nitems-1].cmd == DPS_STACK_ANYWORD) {
return DPS_OK;
}
}
if ((Res->nitems > 0) && (state->cmd == DPS_STACK_WORD)
&& (
(Res->items[Res->nitems-1].cmd == DPS_STACK_WORD)
|| (Res->items[Res->nitems-1].cmd == DPS_STACK_RIGHT)
|| (Res->items[Res->nitems-1].cmd == DPS_STACK_PHRASE_RIGHT)
)) {
Res->items[Res->nitems].cmd = DPS_STACK_OR;
Res->items[Res->nitems].order = 0;
Res->items[Res->nitems].origin = 0;
Res->items[Res->nitems].count = 0;
Res->items[Res->nitems].len = 0;
Res->items[Res->nitems].crcword = 0;
Res->items[Res->nitems].word = NULL;
Res->items[Res->nitems].ulen = 0;
Res->items[Res->nitems].uword = NULL;
Res->items[Res->nitems].pbegin = NULL;
Res->items[Res->nitems].order_origin = 0;
Res->items[Res->nitems].secno = state->secno[state->p_secno];
Res->nitems++;
Res->ncmds++;
#ifdef DEBUG_BOOL
DpsLog(query, DPS_LOG_EXTRA, "1[%d].%x %c -- %s", 0, 0, item_type(DPS_STACK_OR), "<NULL>");
#endif
}
if ((Res->nitems > 0) && (state->cmd == DPS_STACK_LEFT)
&& (
(Res->items[Res->nitems-1].cmd == DPS_STACK_RIGHT)
|| (Res->items[Res->nitems-1].cmd == DPS_STACK_PHRASE_RIGHT)
)) {
Res->items[Res->nitems].cmd = state->add_cmd;
Res->items[Res->nitems].order = 0;
Res->items[Res->nitems].origin = 0;
Res->items[Res->nitems].count = 0;
Res->items[Res->nitems].len = 0;
Res->items[Res->nitems].crcword = 0;
Res->items[Res->nitems].word = NULL;
Res->items[Res->nitems].ulen = 0;
Res->items[Res->nitems].uword = NULL;
Res->items[Res->nitems].pbegin = NULL;
Res->items[Res->nitems].order_origin = 0;
Res->items[Res->nitems].secno = state->secno[state->p_secno];
Res->nitems++;
Res->ncmds++;
#ifdef DEBUG_BOOL
DpsLog(query, DPS_LOG_EXTRA, "1[%d].%x %c -- %s", 0, 0, item_type(state->add_cmd), "<NULL>");
#endif
}
}
Res->items[Res->nitems].cmd = state->cmd;
Res->items[Res->nitems].order = state->order;
Res->items[Res->nitems].order_inquery = state->order_inquery;
Res->items[Res->nitems].origin = origin;
Res->items[Res->nitems].count = 0;
Res->items[Res->nitems].len = (word == NULL) ? 0 : dps_strlen(word);
Res->items[Res->nitems].crcword = crcword;
Res->items[Res->nitems].word = (word == NULL) ? NULL : DpsStrdup(word);
Res->items[Res->nitems].ulen = wlen;
Res->items[Res->nitems].uword = (uword == NULL) ? NULL : DpsUniDup(uword);
Res->items[Res->nitems].pbegin = NULL;
Res->items[Res->nitems].order_origin = 0;
Res->items[Res->nitems].wordnum = Res->nitems;
Res->items[Res->nitems].secno = state->secno[state->p_secno];
Res->nitems++;
if (state->cmd != DPS_STACK_WORD) {
Res->ncmds++;
} else {
Res->items[state->order].order_origin |= origin;
if (state->order > Res->max_order) Res->max_order = state->order;
if (state->order_inquery > Res->max_order_inquery) Res->max_order_inquery = state->order;
}
/* if ((state->cmd == DPS_STACK_WORD) && state->order > Res->max_order) Res->max_order = state->order;*/
#ifdef DEBUG_BOOL
DpsLog(query, DPS_LOG_EXTRA, "1[%d,%d].%x %c -- %s", state->order, state->order_inquery, state->origin, item_type(state->cmd),
(word == NULL) ? "<NULL>" : word);
#endif
return DPS_OK;
}
/* Main function to calculate items sequence */
int
UdmCalcBoolItems(UDM_STACK_ITEM *items, size_t nitems, char *count)
{
UDM_BOOLSTACK s;
int res;
size_t i;
/* Init stack */
s.ncstack= 0;
s.nastack= 0;
s.mcstack= s.mastack = UDM_MAXSTACK;
s.cstack= (int*)UdmMalloc(UDM_MAXSTACK * sizeof(int));
s.astack= (unsigned long*)UdmMalloc(UDM_MAXSTACK * sizeof(unsigned long));
#ifdef DEBUG_BOOL
for (i= 0; i < nitems; i++)
{
fprintf(stderr, "[%d]cmd=%d arg=%d\n", i, items[i].cmd, (int)items[i].arg);
}
#endif
#ifdef DEBUG_BOOL
fprintf(stderr,"--------\n");
#endif
for(i= 0; i < nitems; i++)
{
int c;
#ifdef DEBUG_BOOL
fprintf(stderr,".[%d] %c\n", i, item_type(items[i].cmd, items[i].arg));
#endif
switch((c= items[i].cmd))
{
case UDM_STACK_RIGHT:
/* Perform till LEFT bracket */
while((TOPCMD(&s)!=UDM_STACK_LEFT)&&(TOPCMD(&s)!=UDM_STACK_BOT))
perform(&s,POPCMD(&s));
/* Pop LEFT bracket itself */
if(TOPCMD(&s)==UDM_STACK_LEFT)
POPCMD(&s);
break;
case UDM_STACK_OR:
case UDM_STACK_AND:
while(c<=TOPCMD(&s))
perform(&s,POPCMD(&s));
/* IMPORTANT! No break here! That's OK*/
/* Так надо ! */
case UDM_STACK_LEFT:
case UDM_STACK_NOT:
PUSHCMD(&s,c);
break;
case UDM_STACK_PHRASE:
PUSHARG(&s, (count[items[i+1].arg]) ? 1UL : 0UL);
for (i++; items[i].cmd != UDM_STACK_PHRASE; i++)
#ifdef DEBUG_BOOL
fprintf(stderr,"[%d] %c\n", i, item_type(items[i].cmd, count[items[i].arg]));
fprintf(stderr,"[%d] %c\n", i, item_type(items[i].cmd, count[items[i].arg]));
#endif
;
break;
case UDM_STACK_STOP:
PUSHARG(&s, 1UL);
break;
case UDM_STACK_WORD:
PUSHARG(&s, (count[items[i].arg]) ? 1UL : 0UL);
break;
default:
UDM_ASSERT(0);
}
}
while(TOPCMD(&s) != UDM_STACK_BOT)
perform(&s, POPCMD(&s));
res= POPARG(&s);
UDM_FREE(s.cstack);
UDM_FREE(s.astack);
#ifdef DEBUG_BOOL
fprintf(stderr, "result: %d\n", res);
#endif
return res;
}
