自学教程：C++ GET_FLAG函数代码示例

*/	REBOOL OS_Request_File(REBRFR *fr)/************************************************************************/{	OPENFILENAME ofn = {0};	BOOL ret;	//int err;	REBCHR *filters = TEXT("All files/0*.*/0REBOL scripts/0*.r/0Text files/0*.txt/0"	);	ofn.lStructSize = sizeof(ofn);	// ofn.hwndOwner = WIN_WIN(win); // Must find a way to set this	ofn.lpstrTitle = fr->title;	ofn.lpstrInitialDir = fr->dir;	ofn.lpstrFile = fr->files;	ofn.lpstrFilter = fr->filter ? fr->filter : filters;	ofn.nMaxFile = fr->len;	ofn.lpstrFileTitle = 0;	ofn.nMaxFileTitle = 0;	ofn.Flags = OFN_HIDEREADONLY | OFN_EXPLORER | OFN_NOCHANGEDIR; //|OFN_NONETWORKBUTTON; //;	if (GET_FLAG(fr->flags, FRF_MULTI)) ofn.Flags |= OFN_ALLOWMULTISELECT;	if (GET_FLAG(fr->flags, FRF_SAVE))		ret = GetSaveFileName(&ofn);	else		ret = GetOpenFileName(&ofn);	//if (!ret)	//	err = CommDlgExtendedError(); // CDERR_FINDRESFAILURE	return ret;}

////  Open_IO: C//DEVICE_CMD Open_IO(REBREQ *req){    REBDEV *dev;    dev = Devices[req->device];    // Avoid opening the console twice (compare dev and req flags):    if (GET_FLAG(dev->flags, RDF_OPEN)) {        // Device was opened earlier as null, so req must have that flag:        if (GET_FLAG(dev->flags, SF_DEV_NULL))            SET_FLAG(req->modes, RDM_NULL);        SET_FLAG(req->flags, RRF_OPEN);        return DR_DONE; // Do not do it again    }    if (!GET_FLAG(req->modes, RDM_NULL)) {        // Get the raw stdio handles:        Std_Out = GetStdHandle(STD_OUTPUT_HANDLE);        Std_Inp = GetStdHandle(STD_INPUT_HANDLE);        //Std_Err = GetStdHandle(STD_ERROR_HANDLE);        Std_Echo = 0;        Redir_Out = (GetFileType(Std_Out) != 0);        Redir_Inp = (GetFileType(Std_Inp) != 0);        if (!Redir_Inp || !Redir_Out) {            // If either input or output is not redirected, preallocate            // a buffer for conversion from/to UTF-8.            Std_Buf = OS_ALLOC_N(wchar_t, BUF_SIZE);        }

*/	DEVICE_CMD Write_File(REBREQ *file)/***	Bug?: update file->size value after write !?*************************************************************************/{	if (!file->id) {		file->error = -RFE_NO_HANDLE;		return DR_ERROR;	}	if (GET_FLAG(file->modes, RFM_APPEND)) {		CLR_FLAG(file->modes, RFM_APPEND);		lseek(file->id, 0, SEEK_END);	}	if (file->modes & ((1 << RFM_SEEK) | (1 << RFM_RESEEK) | (1 << RFM_TRUNCATE))) {		CLR_FLAG(file->modes, RFM_RESEEK);		if (!Seek_File_64(file)) return DR_ERROR;		if (GET_FLAG(file->modes, RFM_TRUNCATE))			if (ftruncate(file->id, file->file.index)) return DR_ERROR;	}	if (file->length == 0) return DR_DONE;	file->actual = write(file->id, file->data, file->length);	if (file->actual < 0) {		if (errno == ENOSPC) file->error = -RFE_DISK_FULL;		else file->error = -RFE_BAD_WRITE;		return DR_ERROR;	}	return DR_DONE;}

std::string enchant::print_to_file() const{	std::stringstream out;	out << "Ench: I " << name_ << "/n" << " T "<< type_ << "/n";	for (std::vector<obj_affected_type>::const_iterator i = affected_.begin(),		iend = affected_.end(); i != iend; ++i)	{		out << " A " << i->location << " " << i->modifier << "/n";	}	*buf = '/0';	tascii(&GET_FLAG(affects_flags_, 0), 4, buf);	out << " F " << buf << "/n";	*buf = '/0';	tascii(&GET_FLAG(extra_flags_, 0), 4, buf);	out << " E " << buf << "/n";	*buf = '/0';	tascii(&GET_FLAG(no_flags_, 0), 4, buf);	out << " N " << buf << "/n";	out << " W " << weight_ << "/n";	out << " B " << ndice_ << "/n";	out << " C " << sdice_ << "/n";	out << "~/n";	return out.str();}

static REBCNT find_string(REBSER *series, REBCNT index, REBCNT end, REBVAL *target, REBCNT len, REBCNT flags, REBINT skip){	REBCNT start = index;	if (flags & (AM_FIND_REVERSE | AM_FIND_LAST)) {		skip = -1;		start = 0;		if (flags & AM_FIND_LAST) index = end - len;		else index--;	}	if (ANY_BINSTR(target)) {		// Do the optimal search or the general search?		if (BYTE_SIZE(series) && VAL_BYTE_SIZE(target) && !(flags & ~(AM_FIND_CASE|AM_FIND_MATCH)))			return Find_Byte_Str(series, start, VAL_BIN_DATA(target), len, !GET_FLAG(flags, ARG_FIND_CASE-1), GET_FLAG(flags, ARG_FIND_MATCH-1));		else			return Find_Str_Str(series, start, index, end, skip, VAL_SERIES(target), VAL_INDEX(target), len, flags & (AM_FIND_MATCH|AM_FIND_CASE));	}	else if (IS_BINARY(target)) {		return Find_Byte_Str(series, start, VAL_BIN_DATA(target), len, 0, GET_FLAG(flags, ARG_FIND_MATCH-1));	}	else if (IS_CHAR(target)) {		return Find_Str_Char(series, start, index, end, skip, VAL_CHAR(target), flags);	}	else if (IS_INTEGER(target)) {		return Find_Str_Char(series, start, index, end, skip, (REBUNI)VAL_INT32(target), flags);	}	else if (IS_BITSET(target)) {		return Find_Str_Bitset(series, start, index, end, skip, VAL_SERIES(target), flags);	}	return NOT_FOUND;}

voiddelayed_trigger_activity (){	CHAR_DATA *ch;	//for (ch = character_list; ch; ch = ch->next)	for (std::list<char_data*>::iterator tch_iterator = character_list.begin(); tch_iterator != character_list.end(); tch_iterator++)	{		ch = *tch_iterator;		if (ch->deleted)			continue;		if (GET_FLAG (ch, FLAG_INHIBITTED))		{			if (!GET_FLAG (ch, FLAG_ENTERING) &&				!GET_FLAG (ch, FLAG_LEAVING) && !ch->delay)				ch->flags &= ~FLAG_INHIBITTED;			else				continue;		}		if (ch->trigger_delay && !--(ch->trigger_delay))			trigger (ch, "", ch->trigger_id);	}}

/* * Stream contains open file descriptors that could not be completed. * If stream has only pending open file descriptors close file * descriptors. */static voidcloseStream(){	FileInfo_t *file;	int id;	id = Stream->first;	while (id > EOS) {		PthreadMutexLock(&Stream->mutex);		file = GetFile(id);		PthreadMutexLock(&file->mutex);		if (GET_FLAG(file->flags, FI_DCACHE_CLOSE)) {			if (close(file->dcache) == -1) {				WarnSyscallError(HERE,				    "close", "");			}			CLEAR_FLAG(file->flags, FI_DCACHE);			NumOpenFiles--;		} else if (GET_FLAG(file->flags, FI_DCACHE)) {			SendErrorResponse(file);		}		id = file->next;		PthreadMutexUnlock(&Stream->mutex);		PthreadMutexUnlock(&file->mutex);	}	if (GET_FLAG(Stream->flags, SR_UNAVAIL)) {		rejectRequest(ENODEV, B_TRUE);	} else {		rejectRequest(0, B_TRUE);	}}

*/	DEVICE_CMD Read_DNS(REBREQ *sock)/***		Initiate the GetHost request and return immediately.**		Note the temporary results buffer (must be freed later).*************************************************************************/{	void *host;#ifdef HAS_ASYNC_DNS	HANDLE handle;#else	HOSTENT *he;#endif	host = OS_Make(MAXGETHOSTSTRUCT); // be sure to free it#ifdef HAS_ASYNC_DNS	if (!GET_FLAG(sock->modes, RST_REVERSE)) // hostname lookup		handle = WSAAsyncGetHostByName(Event_Handle, WM_DNS, sock->data, host, MAXGETHOSTSTRUCT);	else		handle = WSAAsyncGetHostByAddr(Event_Handle, WM_DNS, (char*)&(sock->net.remote_ip), 4, AF_INET, host, MAXGETHOSTSTRUCT);	if (handle != 0) {		sock->net.host_info = host;		sock->handle = handle;		return DR_PEND; // keep it on pending list	}#else	// Use old-style blocking DNS (mainly for testing purposes):	if (GET_FLAG(sock->modes, RST_REVERSE)) {		he = gethostbyaddr((char*)&sock->net.remote_ip, 4, AF_INET);		if (he) {			sock->net.host_info = host; //???			sock->data = he->h_name;			SET_FLAG(sock->flags, RRF_DONE);			return DR_DONE;		}	}	else {		he = gethostbyname(sock->data);		if (he) {			sock->net.host_info = host; // ?? who deallocs?			COPY_MEM((char*)&(sock->net.remote_ip), (char *)(*he->h_addr_list), 4); //he->h_length);			SET_FLAG(sock->flags, RRF_DONE);			return DR_DONE;		}	}#endif	OS_Free(host);	sock->net.host_info = 0;	sock->error = GET_ERROR;	//Signal_Device(sock, EVT_ERROR);	return DR_ERROR; // Remove it from pending list}

*/	int OS_Do_Device(REBREQ *req, REBCNT command)/***		Tell a device to perform a command. Non-blocking in many**		cases and will attach the request for polling.****		Returns:**			=0: for command success**			>0: for command still pending**			<0: for command error*************************************************************************/{	REBDEV *dev;	REBINT result;	req->error = 0; // A94 - be sure its cleared	// Validate device:	if (req->device >= RDI_MAX || !(dev = Devices[req->device])) {		req->error = RDE_NO_DEVICE;		return -1;	}	// Confirm device is initialized. If not, return an error or init	// it if auto init option is set.	if (!GET_FLAG(dev->flags, RDF_INIT)) {		if (GET_FLAG(dev->flags, RDO_MUST_INIT)) {			req->error = RDE_NO_INIT;			return -1;		}		if (!dev->commands[RDC_INIT] || !dev->commands[RDC_INIT]((REBREQ*)dev))		SET_FLAG(dev->flags, RDF_INIT);	}	// Validate command:	if (command > dev->max_command || dev->commands[command] == 0) {		req->error = RDE_NO_COMMAND;		return -1;	}	// Do the command:	req->command = command;	result = dev->commands[command](req);	// If request is pending, attach it to device for polling:	if (result > 0) Attach_Request(&dev->pending, req);	else if (dev->pending) {		Detach_Request(&dev->pending, req); // often a no-op		if (result == DR_ERROR && GET_FLAG(req->flags, RRF_ALLOC)) { // not on stack			Signal_Device(req, EVT_ERROR);		}	}	return result;}

void catalog_validate_objects(){    catalog_object_header * i = local_catalog->invalid_list;    while (i != NULL) {        if (GET_FLAG(i->flags, CAT_OBJECT_DELETED_FLAG)) {        } else if (GET_FLAG(i->flags, CAT_OBJECT_INVALID_FLAG)) {            i->validate();        }        i = i->next_invalid;    }    local_catalog->invalid_list = NULL;}

*/	static void Protect_Word(REBVAL *value, REBCNT flags)/************************************************************************/{	if (GET_FLAG(flags, PROT_WORD)) {		if (GET_FLAG(flags, PROT_SET)) VAL_SET_OPT(value, OPTS_LOCK);		else VAL_CLR_OPT(value, OPTS_LOCK);	}	if (GET_FLAG(flags, PROT_HIDE)) {		if GET_FLAG(flags, PROT_SET) VAL_SET_OPT(value, OPTS_HIDE);		else VAL_CLR_OPT(value, OPTS_HIDE);	}

/** * Get the flags associated with a format string * @param format The format string to search. * @param flags A pointer to flags that are turned on. * @return A pointer to the format string */const char *_get_flags(const char *format, uchar *flags){	uchar f;	uchar done = 0;		// start with no flags	CLEAR_FLAGS(f, PRINTF_ALL);		// skip past the % char	++format;		while(!done) {		char ch = *format++;		switch(ch) {		case '-':			// justify, overrides padding			SET_FLAGS(f, PRINTF_JUSTIFY);			CLEAR_FLAGS(f, PRINTF_PADDING);			break;		case '+':			// sign, overrides space			SET_FLAGS(f, PRINTF_SIGN);			CLEAR_FLAGS(f, PRINTF_SPACE);			break;		case ' ':			if(!GET_FLAG(f, PRINTF_SIGN)) {				SET_FLAGS(f, PRINTF_SPACE);			}			break;		case '#':			SET_FLAGS(f, PRINTF_PREFIX);			break;		case '0':			if(!GET_FLAG(f, PRINTF_JUSTIFY)) {				SET_FLAGS(f, PRINTF_PADDING);			}			break;		default:			done = 1;			--format;		}	}	*flags = f;	return format;}

*/	REBCNT Find_Str_Char(REBSER *ser, REBCNT head, REBCNT index, REBCNT tail, REBINT skip, REBUNI c2, REBCNT flags)/***		General purpose find a char in a string.****		Supports: forward/reverse with skip, cased/uncase, Unicode/byte.****		Skip can be set positive or negative (for reverse).****		Flags are set according to ALL_FIND_REFS*************************************************************************/{	REBUNI c1;	REBOOL uncase = !GET_FLAG(flags, ARG_FIND_CASE-1); // uncase = case insenstive	if (uncase && c2 < UNICODE_CASES) c2 = LO_CASE(c2);	for (; index >= head && index < tail; index += skip) {		c1 = GET_ANY_CHAR(ser, index);		if (uncase && c1 < UNICODE_CASES) c1 = LO_CASE(c1);		if (c1 == c2) return index;		if GET_FLAG(flags, ARG_FIND_MATCH-1) break;	}	return NOT_FOUND;}

*/	int OS_Quit_Devices(int flags)/***		Terminate all devices in preparation to quit.****		Allows devices to perform cleanup and resource freeing.****		Set flags to zero for now. (May later be used to indicate**		a device query check or a brute force quit.)****		Returns: 0 for now.*************************************************************************/{	int d;	REBDEV *dev;	for (d = RDI_MAX-1; d >= 0; d--) {		dev = Devices[d];		if (dev && GET_FLAG(dev->flags, RDF_INIT) && dev->commands[RDC_QUIT]) {			dev->commands[RDC_QUIT]((REBREQ*)dev);		}	}	return 0;}

intprocess_output (DESCRIPTOR_DATA * t){  char i[MAX_STRING_LENGTH + 1];  if (!t->prompt_mode && !t->connected && t->edit_index == -1)    if (write_to_descriptor (t, "/r/n") < 0)      return (-1);  /* Cycle thru output queue */  while (get_from_q (&t->output, i))    {      if (t->snoop.snoop_by && t->snoop.snoop_by->desc != NULL	  && !IS_NPC (t->snoop.snoop_by))	{	  write_to_q ("% ", &t->snoop.snoop_by->desc->output);	  write_to_q (i, &t->snoop.snoop_by->desc->output);	}      if (write_to_descriptor (t, i))	return (-1);    }  if (!t->connected && !(t->character && !IS_NPC (t->character) &&			 GET_FLAG (t->character, FLAG_COMPACT)))    if (IS_SET (t->edit_mode, MODE_DONE_EDITING) && t->edit_index == -1)      if (write_to_descriptor (t, "/r/n") < 0)	return (-1);  return (1);}

static voidupdate_sensitivity (void *unused, GtkWidget *dialog){  TerminalSearchDialogPrivate *priv = TERMINAL_SEARCH_DIALOG_GET_PRIVATE (dialog);  const gchar *search_string;  gboolean valid;  if (priv->regex) {    g_regex_unref (priv->regex);    priv->regex = NULL;  }  search_string = gtk_entry_get_text (GTK_ENTRY (priv->search_text_entry));  g_return_if_fail (search_string != NULL);  valid = *search_string != '/0';  if (valid && GET_FLAG (regex_checkbutton)) {    /* Check that the regex is valid */    valid = NULL != terminal_search_dialog_get_regex (dialog);    /* TODO show the error message somewhere */  }  gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT, valid);}

*/	DEVICE_CMD Read_File(REBREQ *file)/************************************************************************/{	if (GET_FLAG(file->modes, RFM_DIR)) {		return Read_Directory(file, (REBREQ*)file->data);	}	if (!file->id) {		file->error = -RFE_NO_HANDLE;		return DR_ERROR;	}	if (file->modes & ((1 << RFM_SEEK) | (1 << RFM_RESEEK))) {		CLR_FLAG(file->modes, RFM_RESEEK);		if (!Seek_File_64(file)) return DR_ERROR;	}	// printf("read %d len %d/n", file->id, file->length);	file->actual = read(file->id, file->data, file->length);	if (file->actual < 0) {		file->error = -RFE_BAD_READ;		return DR_ERROR;	} else {		file->file.index += file->actual;	}	return DR_DONE;}

*/	REBCNT Find_Str_Bitset(REBSER *ser, REBCNT head, REBCNT index, REBCNT tail, REBINT skip, REBSER *bset, REBCNT flags)/***		General purpose find a bitset char in a string.****		Supports: forward/reverse with skip, cased/uncase, Unicode/byte.****		Skip can be set positive or negative (for reverse).****		Flags are set according to ALL_FIND_REFS*************************************************************************/{	REBUNI c1;	REBOOL uncase = !GET_FLAG(flags, ARG_FIND_CASE-1); // uncase = case insenstive	for (; index >= head && index < tail; index += skip) {		c1 = GET_ANY_CHAR(ser, index);		//if (uncase && c1 < UNICODE_CASES) {		//	if (Check_Bit(bset, LO_CASE(c1)) || Check_Bit(bset, UP_CASE(c1)))		//		return index;		//}		//else		if (Check_Bit(bset, c1, uncase)) return index;		if (flags & AM_FIND_MATCH) break;	}	return NOT_FOUND;}

catalog_object_header * catalog_find_name(        enum catalog_named_objects obj_type,        const char * name){    catalog_object_header * result = NULL;    catalog_name_record * n = NULL;    n = catalog_cachetree_find_name(obj_type, name);    if (n != NULL) {        if (n->name_deleted) { return NULL; }        result = n->obj;    }    if (result == NULL) {        xptr obj = catalog_nametree_find_name(CATALOG_NAME_TREE(obj_type), name);        if (obj != XNULL) {            result = catalog_acquire_object(obj);            catalog_cachetree_add_name(obj_type, name, result);        }    } else if (GET_FLAG(result->flags, CAT_OBJECT_DELETED_FLAG)) {        return NULL;    }    return result;}

*/	 DEVICE_CMD Close_Socket(REBREQ *sock)/***		Close a socket.****		Returns 0 on success.**		On failure, error code is OS local.*************************************************************************/{	sock->error = 0;	if (GET_FLAG(sock->state, RSM_OPEN)) {		sock->state = 0;  // clear: RSM_OPEN, RSM_CONNECT		// If DNS pending, abort it:		if (sock->net.host_info) {  // indicates DNS phase active#ifdef HAS_ASYNC_DNS			if (sock->handle) WSACancelAsyncRequest(sock->handle);#endif			OS_Free(sock->net.host_info);			sock->socket = sock->length; // Restore TCP socket (see Lookup)		}		if (CLOSE_SOCKET(sock->socket)) {			sock->error = GET_ERROR;			return DR_ERROR;		}	}	return DR_DONE;}

/* * Open disk cache file. */intDiskCacheOpen(	FileInfo_t *file){	int fd;	/*	 * If saved, restore open disk cache file descriptor.	 * This occurs when processing multivolume.	 */	if (GET_FLAG(file->flags, FI_DCACHE) && file->dcache > 0) {		fd = file->dcache;		Trace(TR_FILES, "Restore disk cache fd: %d", fd);	} else if (ifVerify(file) == B_TRUE) {		fd = openVerify(file);		Trace(TR_FILES, "Verify disk cache fd: %d", fd);	} else {		fd = openStage(file);		Trace(TR_FILES, "Stage disk cache fd: %d", fd);	}	return (fd);}

/* * Is filesystem mounted. */boolean_tIsFileSystemMounted(	equ_t eq){	int i;	struct sam_fs_status *fs;	boolean_t mounted = B_FALSE;	ReconfigLock();		/* wait on reconfig */	for (i = 0; i < fileSystemTable.entries; i++) {		fs = &fileSystemTable.data[i];		if (fs->fs_eq == eq) {			if (GET_FLAG(fs->fs_status, FS_MOUNTED)) {				mounted = B_TRUE;			} else {				struct sam_fs_info fi;				if (GetFsInfo(fs->fs_name, &fi) == -1) {					WarnSyscallError(HERE, "GetFsInfo",					    fs->fs_name);				}				if (fi.fi_status & FS_MOUNTED) {					SET_FLAG(fs->fs_status, FS_MOUNTED);					mounted = B_TRUE;				}			}			break;		}	}	ReconfigUnlock();		/* allow reconfig */	return (mounted);}

*/	void Ret_Query_File(REBSER *port, REBREQ *file, REBVAL *ret)/***		Query file and set RET value to resulting STD_FILE_INFO object.*************************************************************************/{	REBVAL *info = In_Object(port, STD_PORT_SCHEME, STD_SCHEME_INFO, 0);	REBSER *obj;	REBSER *ser;	if (!info || !IS_OBJECT(info)) Trap_Port(RE_INVALID_SPEC, port, -10);	obj = CLONE_OBJECT(VAL_OBJ_FRAME(info));	SET_OBJECT(ret, obj);	Init_Word_Unbound(		OFV(obj, STD_FILE_INFO_TYPE),		REB_WORD,		GET_FLAG(file->modes, RFM_DIR) ? SYM_DIR : SYM_FILE	);	SET_INTEGER(OFV(obj, STD_FILE_INFO_SIZE), file->special.file.size);	Set_File_Date(file, OFV(obj, STD_FILE_INFO_DATE));	ser = To_REBOL_Path(file->special.file.path, 0, OS_WIDE, 0);	Set_Series(REB_FILE, OFV(obj, STD_FILE_INFO_NAME), ser);}

void OpenCLCommandQueue :: create(OpenCLContext &ctx, const OpenCLDevice &dev, bool ordered, bool profiling) {	destroy();	detach();		cl_command_queue_properties properties = 0;	if(profiling) {		properties |= CL_QUEUE_PROFILING_ENABLE;	}	if(! ordered) {		if(GET_FLAG(CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, dev.get_queue_properties())) {			properties |= CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;		}		else {			opencl_error(USER_OPENCL_ERROR, "Device doesn't support out of order execution ... disabling");		}	}		cl_int res = CL_SUCCESS;	cl_command_queue command_queue = clCreateCommandQueue(		ctx.get_context(),		dev.get_device(),		properties,		&res	);		if(opencl_error(res, "clCreateCommandQueue error creating command queue")) {		return;	}		mCommandQueue = command_queue;	ctx.attach_resource(this);}

GRegex *terminal_search_dialog_get_regex (GtkWidget *dialog){  TerminalSearchDialogPrivate *priv;  GRegexCompileFlags compile_flags;  const char *text, *pattern;  g_return_val_if_fail (GTK_IS_DIALOG (dialog), NULL);  priv = TERMINAL_SEARCH_DIALOG_GET_PRIVATE (dialog);  g_return_val_if_fail (priv, NULL);  pattern = text = terminal_search_dialog_get_search_text (dialog);  compile_flags = G_REGEX_OPTIMIZE;  if (!GET_FLAG (match_case_checkbutton))    compile_flags |= G_REGEX_CASELESS;  if (GET_FLAG (regex_checkbutton))    compile_flags |= G_REGEX_MULTILINE;  else    pattern = g_regex_escape_string (text, -1);  if (GET_FLAG (entire_word_checkbutton)) {    const char *old_pattern = pattern;    pattern = g_strdup_printf ("//b%s//b", pattern);    if (old_pattern != text)      g_free ((char *) old_pattern);  }  if (!priv->regex || priv->regex_compile_flags != compile_flags ||      g_strcmp0 (pattern, g_regex_get_pattern (priv->regex)) != 0) {    priv->regex_compile_flags = compile_flags;    if (priv->regex)      g_regex_unref (priv->regex);    /* TODO Error handling */    priv->regex = g_regex_new (pattern, compile_flags, 0, NULL);  }  if (pattern != text)    g_free ((char *) pattern);  return priv->regex;}

/* * Remove file with dcache opened from stream. * Caller must have the stream lock held. */static voidremoveDcachedFile(	StreamInfo_t *stream,	int error){	int id;	FileInfo_t *file, *prev = NULL;	id = stream->first;	while (id > EOS) {		boolean_t removed = B_FALSE;		file = GetFile(id);		PthreadMutexLock(&file->mutex);		if (prev != NULL) {			PthreadMutexLock(&prev->mutex);		}		if (GET_FLAG(file->flags, FI_DCACHE)) {			/*			 * Remove file from stream.			 * If multivolume and not section 0, set ECOMM to not			 * retry from another copy.			 */			if (file->ar[file->copy].ext_ord != 0 ||			    file->se_ord != 0) {				file->error = ECOMM;			} else {				file->error = error;			}			SendErrorResponse(file);			if (prev != NULL) {				prev->next = file->next;			} else {				stream->first = file->next;			}			stream->count--;			if (stream->first == EOS) {				stream->last = EOS;			} else if (file->sort == stream->last) {				ASSERT(prev != NULL);				stream->last = prev->sort;			}			removed = B_TRUE;		}		if (prev != NULL) {			PthreadMutexUnlock(&prev->mutex);		}		PthreadMutexUnlock(&file->mutex);		id = file->next;		if (removed) {			SetStageDone(file);		} else {			prev = file;		}	}}

*/	static int Read_Dir(REBREQ *dir, REBSER *files)/***		Provide option to get file info too.**		Provide option to prepend dir path.**		Provide option to use wildcards.*************************************************************************/{	REBINT result;	REBCNT len;	REBSER *fname;	REBSER *name;	REBREQ file;	RESET_TAIL(files);	CLEARS(&file);	// Temporary filename storage:	fname = BUF_OS_STR;	file.special.file.path = cast(REBCHR*, Reset_Buffer(fname, MAX_FILE_NAME));	SET_FLAG(dir->modes, RFM_DIR);	dir->common.data = cast(REBYTE*, &file);	while ((result = OS_DO_DEVICE(dir, RDC_READ)) == 0 && !GET_FLAG(dir->flags, RRF_DONE)) {		len = OS_STRLEN(file.special.file.path);		if (GET_FLAG(file.modes, RFM_DIR)) len++;		name = Copy_OS_Str(file.special.file.path, len);		if (GET_FLAG(file.modes, RFM_DIR))			SET_ANY_CHAR(name, name->tail-1, '/');		Val_Init_File(Alloc_Tail_Array(files), name);	}	if (result < 0 && dir->error != -RFE_OPEN_FAIL		&& (			OS_STRCHR(dir->special.file.path, '*')			|| OS_STRCHR(dir->special.file.path, '?')		)	) {		result = 0;  // no matches found, but not an error	}	return result;}

TerminalSearchFlagsterminal_search_dialog_get_search_flags (GtkWidget *dialog){  TerminalSearchDialogPrivate *priv;  TerminalSearchFlags flags = 0;  g_return_val_if_fail (GTK_IS_DIALOG (dialog), flags);  priv = TERMINAL_SEARCH_DIALOG_GET_PRIVATE (dialog);  g_return_val_if_fail (priv, flags);  if (GET_FLAG (backwards_checkbutton))    flags |= TERMINAL_SEARCH_FLAG_BACKWARDS;  if (GET_FLAG (wrap_around_checkbutton))    flags |= TERMINAL_SEARCH_FLAG_WRAP_AROUND;  return flags;}