/* Returns the element before ELEM in its list. If ELEM is the
first element in its list, returns the list head. Results are
undefined if ELEM is itself a list head. */
struct list_elem *
list_prev (struct list_elem *elem)
{
ASSERT (list_is_interior (elem) || is_tail (elem));
ASSERT (is_list_elem (elem->prev));
return elem->prev;
}
struct list_elem
*list_prev(struct list_elem *e)
{
assert(e);
assert(is_interior(e) || is_tail(e));
return e->prev;
}
bool xrCompressor::testSKIP(LPCSTR path)
{
string256 p_name;
string256 p_ext;
_splitpath (path, 0, 0, p_name, p_ext );
if (strstr(path,"textures\\lod\\")) return true;
if (strstr(path,"textures\\det\\")) return true;
if ( stricmp(p_ext,".thm") &&
strstr(path,"textures\\terrain\\terrain_") &&
!is_tail(p_name,"_mask",5)
)
return true;
if (strstr(path,"textures\\") && is_tail(p_name, "_nmap",5) && !strstr(p_name, "water_flowing_nmap") )
return true;
if (0==stricmp(p_name,"build"))
{
if (0==stricmp(p_ext,".aimap") ) return true;
if (0==stricmp(p_ext,".cform") ) return true;
if (0==stricmp(p_ext,".details")) return true;
if (0==stricmp(p_ext,".prj") ) return true;
if (0==stricmp(p_ext,".lights") ) return false;
}
if (0==stricmp(p_name,"do_light") && 0==stricmp(p_ext,".ltx")) return true;
if (0==stricmp(p_ext,".txt")) return true;
if (0==stricmp(p_ext,".tga")) return true;
if (0==stricmp(p_ext,".db")) return true;
if (0==stricmp(p_ext,".smf")) return true;
if ('~'==p_ext[1]) return true;
if ('_'==p_ext[1]) return true;
if (0==stricmp(p_ext,".vcproj")) return true;
if (0==stricmp(p_ext,".sln")) return true;
if (0==stricmp(p_ext,".old")) return true;
if (0==stricmp(p_ext,".rc")) return true;
for (xr_vector<shared_str>::iterator it=exclude_exts.begin(); it!=exclude_exts.end(); ++it)
if (PatternMatch(p_ext,it->c_str()))
return true;
return false;
}
/* Inserts ELEM just before BEFORE, which may be either an
interior element or a tail. The latter case is equivalent to
list_push_back(). */
void
list_insert (struct list_elem *before, struct list_elem *elem)
{
ASSERT (is_interior (before) || is_tail (before));
ASSERT (elem != NULL);
elem->prev = before->prev;
elem->next = before;
before->prev->next = elem;
before->prev = elem;
}
void
list_insert (struct list_elem *before, struct list_elem *elem)
{
ASSERT (is_interior (before) == true || is_tail (before) == true);
ASSERT (NULL != elem);
elem->prev = before->prev;
elem->next = before;
before->prev->next = elem;
before->prev = elem;
}
/* Inserts ELEM just before BEFORE, which may be either an
interior element or a tail. The latter case is equivalent to
list_push_back(). */
void
list_insert (struct list_elem *before, struct list_elem *elem)
{
ASSERT (before != NULL && elem != NULL);
ASSERT (list_is_interior (before) || is_tail (before));
elem->magic = LIST_ELEM_MAGIC__;
elem->prev = before->prev;
elem->next = before;
before->prev->next = elem;
before->prev = elem;
}
/* Inserts ELEM just before BEFORE, which may be either an
interior element or a tail. The latter case is equivalent to
list_push_back(). */
void
list_insert (struct list_elem *before, struct list_elem *elem)
{
ASSERT (is_interior (before) || is_tail (before));
ASSERT (elem != NULL);
/* Abraham driving */
//elem->node_lock = before->node_lock; /* gave a copy of the lock to the new element we just added */
elem->prev = before->prev;
elem->next = before;
before->prev->next = elem;
before->prev = elem;
}
/* Removes elements FIRST though LAST (exclusive) from their
current list, then inserts them just before BEFORE, which may
be either an interior element or a tail. */
void
list_splice (struct list_elem *before,
struct list_elem *first, struct list_elem *last)
{
ASSERT (is_interior (before) || is_tail (before));
if (first == last)
return;
last = list_prev (last);
ASSERT (is_interior (first));
ASSERT (is_interior (last));
/* Cleanly remove FIRST...LAST from its current list. */
first->prev->next = last->next;
last->next->prev = first->prev;
/* Splice FIRST...LAST into new list. */
first->prev = before->prev;
last->next = before;
before->prev->next = first;
before->prev = last;
}
/* input line with encoding conversion */
long input_line2(FILE *fp, unsigned char *buff, long pos,
const long buffsize, int *lastchar)
{
long i;
static boolean injis = false;
const int fd = fileno(fp);
if (infile_enc[fd] == ENC_UNKNOWN) { /* just after opened */
ungetbuff[fd].size = 0;
if (isUTF8Nstream(fp)) infile_enc[fd] = ENC_UTF8;
else infile_enc[fd] = get_file_enc();
}
buffer = buff;
first = last = pos;
while (last < buffsize-30 && (i=getc4(fp)) != EOF && i!='\n' && i!='\r') {
/* 30 is enough large size for one char */
/* attention: 4 times of write_hex() eats 16byte */
#ifdef WIN32
if (i == 0x1a && first == last &&
fd == fileno(stdin) && _isatty(fd)) { /* Ctrl+Z on console */
i = EOF;
break;
} else
#endif
if (i == ESC) {
if ((i=getc4(fp)) == '$') { /* ESC '$' (Kanji-in) */
i = getc4(fp);
if (i == '@' || i == 'B') {
injis = true;
} else { /* broken Kanji-in */
buffer[last++] = ESC;
buffer[last++] = '$';
if (is_tail(&i, fp)) break;
buffer[last++] = i;
}
} else if (i == '(') { /* ESC '(' (Kanji-out) */
i = getc4(fp);
if (i == 'J' || i == 'B' || i == 'H') {
injis = false;
} else { /* broken Kanji-out */
buffer[last++] = ESC;
buffer[last++] = '(';
if (is_tail(&i, fp)) break;
buffer[last++] = i;
}
} else { /* broken ESC */
buffer[last++] = ESC;
if (is_tail(&i, fp)) break;
buffer[last++] = i;
}
} else { /* rather than ESC */
if (injis) { /* in JIS */
long j = getc4(fp);
if (is_tail(&j, fp)) {
buffer[last++] = i;
i = j;
break;
} else { /* JIS encoding */
i = fromJIS(HILO(i,j));
if (i == 0) i = fromUCS(U_REPLACEMENT_CHARACTER);
write_multibyte(toBUFF(i));
}
} else { /* normal */
if (infile_enc[fd] == ENC_SJIS && isSJISkanji1(i)) {
get_sjis(i, fp);
} else if (infile_enc[fd] == ENC_EUC && isEUCkanji1(i)) {
get_euc(i, fp);
} else if (infile_enc[fd] == ENC_UTF8 && UTF8length(i) > 1) {
get_utf8(i, fp);
} else {
buffer[last++] = i;
}
}
}
}
buffer[last] = '\0';
if (i == EOF || i == '\n' || i == '\r') injis = false;
if (lastchar != NULL) *lastchar = i;
return last;
}
/* Returns the element before ELEM in its list. If ELEM is the
first element in its list, returns the list head. Results are
undefined if ELEM is itself a list head. */
struct list_elem *
list_prev (struct list_elem *elem)
{
assert (is_interior (elem) || is_tail (elem));
return elem->prev;
}
void C_leer_ficha(void *environment, DATA_OBJECT_PTR returnValuePtr)
{
SDL_Event evento;
int x, y, pos, head=1;
void *retorno;
char fin=0, fin2=0;
if (n == 0) {
x=-1;
y=-1;
fin = 1;
}
leyendo=1;
while (!fin) {
while (SDL_PollEvent(&evento)) {
switch (evento.type) {
case SDL_QUIT:
SDL_Quit();
fin = 1;
break;
case SDL_MOUSEBUTTONDOWN:
if (evento.button.button == SDL_BUTTON_RIGHT) {
x=-1; y=-1;
fin = 1;
break;
}
if (evento.button.y >= FICHAS_Y &&
evento.button.y <= FICHAS_Y + fichaH) {
for (pos=0; pos<n; ++pos) {
if (evento.button.y >= FICHAS_Y &&
evento.button.y <= FICHAS_Y + fichaH) {
if (evento.button.x >= (30 + pos*(fichaW + 10)) &&
evento.button.x <= (30 + pos*(fichaW + 10) + fichaW)) {
if (evento.button.y > FICHAS_Y + fichaH/2) {
x = fichas[jugador[pos]].y;
y = fichas[jugador[pos]].x;
}
else {
x = fichas[jugador[pos]].x;
y = fichas[jugador[pos]].y;
}
fin2=0;
while (!fin2) {
SDL_PollEvent(&evento);
switch (evento.type) {
case SDL_MOUSEBUTTONDOWN:
if (evento.button.button == SDL_BUTTON_RIGHT) fin2=1;
else {
if (is_head (evento.button.x, evento.button.y))
fin=1, fin2=1;
else if (is_tail (evento.button.x, evento.button.y)) {
fin = x;
x = y;
y = fin;
fin = 1;
head = 0;
fin2=1;
}
}
break;
}
}
}
}
}
}
break;
}
}
C_flip(environment);
}
retorno = EnvCreateMultifield(environment,3);
SetMFType(retorno, 1, INTEGER);
SetMFValue(retorno, 1, EnvAddLong(environment,x));
SetMFType(retorno, 2, INTEGER);
SetMFValue(retorno, 2, EnvAddLong(environment,y));
SetMFType(retorno, 3, INTEGER);
SetMFValue(retorno, 3, EnvAddLong(environment,head));
SetpType(returnValuePtr, MULTIFIELD);
SetpValue(returnValuePtr, retorno);
SetpDOBegin(returnValuePtr, 1);
SetpDOEnd(returnValuePtr, 3);
n=0;
while (SDL_PollEvent(&evento));
}
