/* 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)); }