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

/*! * /brief Locking all or selected elements. * * Usage:/n * UnlockElements(All)/n * UE(All)/n        * If no argument is passed, no action is carried out. */static intunlock_elements (int argc, char **argv, Coord x, Coord y){        int all = 0;        if (strcasecmp (argv[0], "All") == 0)                all = 1;        else        {                Message ("ERROR: in UnlockElements argument should be All./n");                return 1;        }        SET_FLAG (NAMEONPCBFLAG, PCB);        ELEMENT_LOOP(PCB->Data);        {                if (TEST_FLAG (LOCKFLAG, element))                {                        /* element is locked */                        if (all)                                CLEAR_FLAG(LOCKFLAG, element);                }        }        END_LOOP;        gui->invalidate_all ();        IncrementUndoSerialNumber ();        return 0;}

BOOLEANSpTerminateAdapterSynchronized(    IN PADAPTER_EXTENSION Adapter    ){    //    // Disable the interrupt from coming in.    //    SET_FLAG(Adapter->InterruptData.InterruptFlags, PD_ADAPTER_REMOVED);    CLEAR_FLAG(Adapter->InterruptData.InterruptFlags, PD_RESET_HOLD);    ScsiPortCompleteRequest(Adapter->HwDeviceExtension,                            0xff,                            0xff,                            0xff,                            SRB_STATUS_NO_HBA);    //    // Run the completion DPC.    //    if(TEST_FLAG(Adapter->InterruptData.InterruptFlags,                 PD_NOTIFICATION_REQUIRED)) {        SpRequestCompletionDpc(Adapter->DeviceObject);    }    return TRUE;}

void delete_value(unit_box *boxes, INDEX index, INDEX i,INDEX j){    INDEX ri = 0, ci = 0, bi = 0;    UNIT val = 0;    bi = index;    ri = GET_ROW(bi)*COLUMN + i;     ci = GET_COLUMN(bi)*ROW + j;    val = boxes[index].value[i][j];    if(val > 0 && val <= TOTAL)    {        boxes[index].value[i][j] = 0;        CLEAR_FLAG(box[bi], val-1);        CLEAR_FLAG(row[ri], val-1);        CLEAR_FLAG(column[ci], val-1);    }}

/*! /brief  Receive one byte. * *  This function receives one byte of data *  by accessing the Rx buffer. * *  /note   The SW_UART_RX_BUFFER_FULL flag *          must be one when this function *          is called. * *  /return Data received. */uint8_t SW_UART_Receive(void){  uint8_t data;  data = UART_Rx_buffer;  CLEAR_FLAG( SW_UART_status, SW_UART_RX_BUFFER_FULL );  return data;}

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

/* --------------------------------------------------------------------------- * moves a text object between layers; lowlevel routines */static void *MoveTextToLayerLowLevel (LayerType *Source, TextType *text,			 LayerType *Destination){  RestoreToPolygon (PCB->Data, TEXT_TYPE, Source, text);  r_delete_entry (Source->text_tree, (BoxType *)text);  Source->Text = g_list_remove (Source->Text, text);  Source->TextN --;  Destination->Text = g_list_append (Destination->Text, text);  Destination->TextN ++;  if (GetLayerGroupNumberByNumber (solder_silk_layer) ==      GetLayerGroupNumberByPointer (Destination))    SET_FLAG (ONSOLDERFLAG, text);  else    CLEAR_FLAG (ONSOLDERFLAG, text);  /* re-calculate the bounding box (it could be mirrored now) */  SetTextBoundingBox (&PCB->Font, text);  if (!Destination->text_tree)    Destination->text_tree = r_create_tree (NULL, 0, 0);  r_insert_entry (Destination->text_tree, (BoxType *)text, 0);  ClearFromPolygon (PCB->Data, TEXT_TYPE, Destination, text);  return text;}

NTSTATUSNTAPITGitNtQueryDirectoryFile(    HANDLE                  FileHandle,    HANDLE                  Event  OPTIONAL,    PIO_APC_ROUTINE         ApcRoutine  OPTIONAL,    PVOID                   ApcContext  OPTIONAL,    PIO_STATUS_BLOCK        IoStatusBlock,    PVOID                   FileInformation,    ULONG                   Length,    FILE_INFORMATION_CLASS  FileInformationClass,    BOOLEAN                 ReturnSingleEntry,    PUNICODE_STRING         FileName  OPTIONAL,    BOOLEAN                 RestartScan){    NTSTATUS Status;    Status = StubNtQueryDirectoryFile(FileHandle, Event, ApcRoutine, ApcContext, IoStatusBlock, FileInformation, Length, FileInformationClass, ReturnSingleEntry, FileName, RestartScan);    if (NT_SUCCESS(Status) && FileInformationClass == FileBothDirectoryInformation)    {        PFILE_BOTH_DIR_INFORMATION FileInfo;        FileInfo = (PFILE_BOTH_DIR_INFORMATION)FileInformation;        if (FileInfo != NULL)        {            CLEAR_FLAG(FileInfo->FileAttributes, FILE_ATTRIBUTE_REPARSE_POINT);        }    }    return Status;}

/** * Can the player be saved by an item? * @param op Player to try to save. * @retval 1 Player had his life saved by an item, first item saving life * is removed. * @retval 0 Player had no life-saving item. */static int save_life(object *op){	object *tmp;	if (!QUERY_FLAG(op, FLAG_LIFESAVE))	{		return 0;	}	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	{		if (QUERY_FLAG(tmp, FLAG_APPLIED) && QUERY_FLAG(tmp, FLAG_LIFESAVE))		{			play_sound_map(op->map, op->x, op->y, SOUND_OB_EVAPORATE, SOUND_NORMAL);			new_draw_info_format(NDI_UNIQUE, op, "Your %s vibrates violently, then evaporates.", query_name(tmp, NULL));			if (CONTR(op))			{				esrv_del_item(CONTR(op), tmp->count, tmp->env);			}			remove_ob(tmp);			CLEAR_FLAG(op, FLAG_LIFESAVE);			if (op->stats.hp < 0)			{				op->stats.hp = op->stats.maxhp;			}			if (op->stats.food < 0)			{				op->stats.food = 999;			}			/* Bring him home. */			enter_player_savebed(op);			return 1;		}	}	LOG(llevBug, "BUG: save_life(): LIFESAVE set without applied object./n");	CLEAR_FLAG(op, FLAG_LIFESAVE);	/* Bring him home. */	enter_player_savebed(op);	return 0;}

inline void catalog_object_header::validate() {    //S_LOCK(lock);    cs_pushp();    if (object != NULL) object->serialize();    cs_popp();    CLEAR_FLAG(flags, CAT_OBJECT_INVALID_FLAG);    //S_UNLOCK(lock);};

//setup to run the code at the address, that the Interrupt Vector points to...static voidsetupInt(int intNum){	DEBUG_PRINTF_INTR("%s(%x): executing interrupt handler @%08x/n",			  __func__, intNum, my_rdl(intNum * 4));	// push current R_FLG... will be popped by IRET	push_word((u16) M.x86.R_FLG);	CLEAR_FLAG(F_IF);	CLEAR_FLAG(F_TF);	// push current CS:IP to the stack, will be popped by IRET	push_word(M.x86.R_CS);	push_word(M.x86.R_IP);	// set CS:IP to the interrupt handler address... so the next executed instruction will	// be the interrupt handler	M.x86.R_CS = my_rdw(intNum * 4 + 2);	M.x86.R_IP = my_rdw(intNum * 4);}

/* --------------------------------------------------------------------------- * moves a element to buffer without allocating memory for pins/names */static void *MoveElementToBuffer (ElementType *element){  /*   * Delete the element from the source (remove it from trees,   * restore to polygons)   */  r_delete_element (Source, element);  Source->Element = g_list_remove (Source->Element, element);  Source->ElementN --;  Dest->Element = g_list_append (Dest->Element, element);  Dest->ElementN ++;  PIN_LOOP (element);  {    RestoreToPolygon(Source, PIN_TYPE, element, pin);    CLEAR_FLAG (WARNFLAG | NOCOPY_FLAGS, pin);  }  END_LOOP;  PAD_LOOP (element);  {    RestoreToPolygon(Source, PAD_TYPE, element, pad);    CLEAR_FLAG (WARNFLAG | NOCOPY_FLAGS, pad);  }  END_LOOP;  SetElementBoundingBox (Dest, element, &PCB->Font);  /*   * Now clear the from the polygons in the destination   */  PIN_LOOP (element);  {    ClearFromPolygon (Dest, PIN_TYPE, element, pin);  }  END_LOOP;  PAD_LOOP (element);  {    ClearFromPolygon (Dest, PAD_TYPE, element, pad);  }  END_LOOP;  return element;}

/****************************************************************************REMARKS:Handles any pending asychronous interrupts.****************************************************************************/static void x86emu_intr_handle(void){	u8	intno;	if (M.x86.intr & INTR_SYNCH) {		intno = M.x86.intno;		if (_X86EMU_intrTab[intno]) {			(*_X86EMU_intrTab[intno])(intno);		} else {			push_word((u16)M.x86.R_FLG);			CLEAR_FLAG(F_IF);			CLEAR_FLAG(F_TF);			push_word(M.x86.R_CS);			M.x86.R_CS = mem_access_word(intno * 4 + 2);			push_word(M.x86.R_IP);			M.x86.R_IP = mem_access_word(intno * 4);			M.x86.intr = 0;		}	}}

void NetConnection::shutdown(){   if ( IS_SET(mFlags, eConnected) )   {      CLEAR_FLAG(mFlags, eConnected);      mSocket.close();      // remove the clients      mClients.clear();   }}

void Set_RA_LDPC_8812(struct sta_info *psta, BOOLEAN bLDPC){	if (psta == NULL)		return;#ifdef CONFIG_80211AC_VHT	if (psta->wireless_mode == WIRELESS_11_5AC) {		if (bLDPC && TEST_FLAG(psta->vhtpriv.ldpc_cap, LDPC_VHT_CAP_TX))			SET_FLAG(psta->vhtpriv.ldpc_cap, LDPC_VHT_ENABLE_TX);		else			CLEAR_FLAG(psta->vhtpriv.ldpc_cap, LDPC_VHT_ENABLE_TX);	} else		if (IsSupportedTxHT(psta->wireless_mode) || IsSupportedVHT(psta->wireless_mode)) {			if (bLDPC && TEST_FLAG(psta->htpriv.ldpc_cap, LDPC_HT_CAP_TX))				SET_FLAG(psta->htpriv.ldpc_cap, LDPC_HT_ENABLE_TX);			else				CLEAR_FLAG(psta->htpriv.ldpc_cap, LDPC_HT_ENABLE_TX);		}#endif	/* DBG_871X("MacId %d bLDPC %d/n", psta->mac_id, bLDPC); */}

BOOLEANSpRemoveAdapterSynchronized(    PADAPTER_EXTENSION Adapter    ){    //    // Disable the interrupt from coming in.    //    SET_FLAG(Adapter->InterruptData.InterruptFlags, PD_ADAPTER_REMOVED);    CLEAR_FLAG(Adapter->InterruptData.InterruptFlags, PD_RESET_HOLD);    return TRUE;}

void update_params(unit_box *boxes, inv_unit_box *box, inv_unit_box *row, inv_unit_box *column){    INDEX i=0, j=0, bi=0;    for(i = 0 ; i < TOTAL ; i++)        for(j = 0 ; j < TOTAL ; j++)        {            CLEAR_FLAG(box[i], j);            CLEAR_FLAG(row[i], j);            CLEAR_FLAG(column[i], j);        }    for( bi= 0; bi < TOTAL; bi++)        for( i= 0; i < COLUMN; i++)        {            INDEX ri = GET_ROW(bi)*COLUMN + i;            for(j= 0; j < ROW; j++)            {                INDEX ci = GET_COLUMN(bi)*ROW + j;                UNIT val = boxes[bi].value[i][j]-1;                SET_FLAG(box[bi], val);                SET_FLAG(row[ri], val);                SET_FLAG(column[ci], val);            }        }}

/** * Handles showing of a trap. * @param trap The trap. * @param where Where. * @return 1 if the trap was shown, 0 otherwise. */int trap_show(object *trap, object *where){	object *env;	if (where == NULL)	{		return 0;	}	env = trap->env;	/* We must remove and reinsert it.. */	remove_ob(trap);	CLEAR_FLAG(trap, FLAG_SYS_OBJECT);	CLEAR_MULTI_FLAG(trap, FLAG_IS_INVISIBLE);	trap->layer = LAYER_EFFECT;	if (env && env->type != PLAYER && env->type != MONSTER && env->type != DOOR && !QUERY_FLAG(env, FLAG_NO_PASS))	{		SET_FLAG(env, FLAG_IS_TRAPPED);		/* Env object is on map */		if (!env->env)		{			update_object(env, UP_OBJ_FACE);		}		/* Somewhere else - if visible, update */		else		{			if (env->env->type == PLAYER || env->env->type == CONTAINER)			{				esrv_update_item(UPD_FLAGS, env->env, env);			}		}		insert_ob_in_ob(trap, env);		if (env->type == PLAYER || env->type == CONTAINER)		{			esrv_update_item(UPD_LOCATION, env, trap);		}	}	else	{		insert_ob_in_map(trap, where->map, NULL, 0);	}	return 1;}

/* --------------------------------------------------------------------------- * moves a rat-line to paste buffer */static void *MoveRatToBuffer (RatType *rat){  r_delete_entry (Source->rat_tree, (BoxType *)rat);  Source->Rat = g_list_remove (Source->Rat, rat);  Source->RatN --;  Dest->Rat = g_list_append (Dest->Rat, rat);  Dest->RatN ++;  CLEAR_FLAG (NOCOPY_FLAGS, rat);  if (!Dest->rat_tree)    Dest->rat_tree = r_create_tree (NULL, 0, 0);  r_insert_entry (Dest->rat_tree, (BoxType *)rat, 0);  return rat;}

NTSTATUSNTAPITGitNtQueryFullAttributesFile(    POBJECT_ATTRIBUTES              ObjectAttributes,    PFILE_NETWORK_OPEN_INFORMATION  FileInformation){    NTSTATUS Status;    Status = StubNtQueryFullAttributesFile(ObjectAttributes, FileInformation);    if (NT_SUCCESS(Status))    {        CLEAR_FLAG(FileInformation->FileAttributes, FILE_ATTRIBUTE_REPARSE_POINT);    }    return Status;}

/* --------------------------------------------------------------------------- * moves a via to paste buffer without allocating memory for the name */static void *MoveViaToBuffer (PinType *via){  RestoreToPolygon (Source, VIA_TYPE, via, via);  r_delete_entry (Source->via_tree, (BoxType *) via);  Source->Via = g_list_remove (Source->Via, via);  Source->ViaN --;  Dest->Via = g_list_append (Dest->Via, via);  Dest->ViaN ++;  CLEAR_FLAG (WARNFLAG | NOCOPY_FLAGS, via);  if (!Dest->via_tree)    Dest->via_tree = r_create_tree (NULL, 0, 0);  r_insert_entry (Dest->via_tree, (BoxType *)via, 0);  ClearFromPolygon (Dest, VIA_TYPE, via, via);  return via;}

/** * This is similar to handle_player(), but is only used by the new * client/server stuff. * * This is sort of special, in that the new client/server actually uses * the new speed values for commands. * @param pl Player to handle. * @retval -1 Player is invalid. * @retval 0 No more actions to do. * @retval 1 There are more actions we can do. */int handle_newcs_player(player *pl){	object *op = pl->ob;	if (!op || !OBJECT_ACTIVE(op))	{		return -1;	}	handle_client(&pl->socket, pl);	if (!op || !OBJECT_ACTIVE(op) || pl->socket.status == Ns_Dead)	{		return -1;	}	/* Check speed. */	if (op->speed_left < 0.0f)	{		return 0;	}	/* If we are here, we're never paralyzed anymore. */	CLEAR_FLAG(op, FLAG_PARALYZED);	if (op->direction && (CONTR(op)->run_on || CONTR(op)->fire_on))	{		/* All move commands take 1 tick, at least for now. */		op->speed_left--;		move_player(op, op->direction);		if (op->speed_left > 0)		{			return 1;		}		else		{			return 0;		}	}	return 0;}

/* --------------------------------------------------------------------------- * moves a polygon to buffer. Doesn't allocate memory for the points */static void *MovePolygonToBuffer (LayerType *layer, PolygonType *polygon){  LayerType *lay = &Dest->Layer[GetLayerNumber (Source, layer)];  r_delete_entry (layer->polygon_tree, (BoxType *)polygon);  layer->Polygon = g_list_remove (layer->Polygon, polygon);  layer->PolygonN --;  lay->Polygon = g_list_append (lay->Polygon, polygon);  lay->PolygonN ++;  CLEAR_FLAG (NOCOPY_FLAGS, polygon);  if (!lay->polygon_tree)    lay->polygon_tree = r_create_tree (NULL, 0, 0);  r_insert_entry (lay->polygon_tree, (BoxType *)polygon, 0);  return (polygon);}

/* --------------------------------------------------------------------------- * copies data from one polygon to another * 'Dest' has to exist */PolygonType *CopyPolygonLowLevel (PolygonType *Dest, PolygonType *Src){  Cardinal hole = 0;  Cardinal n;  for (n = 0; n < Src->PointN; n++)    {      if (hole < Src->HoleIndexN && n == Src->HoleIndex[hole])        {          CreateNewHoleInPolygon (Dest);          hole++;        }      CreateNewPointInPolygon (Dest, Src->Points[n].X, Src->Points[n].Y);    }  SetPolygonBoundingBox (Dest);  Dest->Flags = Src->Flags;  CLEAR_FLAG (NOCOPY_FLAGS, Dest);  return (Dest);}

/* --------------------------------------------------------------------------- * copies a polygon to buffer */static void *AddPolygonToBuffer (LayerType *Layer, PolygonType *Polygon){  LayerType *layer = &Dest->Layer[GetLayerNumber (Source, Layer)];  PolygonType *polygon;  polygon = CreateNewPolygon (layer, Polygon->Flags);  CopyPolygonLowLevel (polygon, Polygon);  /* Update the polygon r-tree. Unlike similarly named functions for   * other objects, CreateNewPolygon does not do this as it creates a   * skeleton polygon object, which won't have correct bounds.   */  if (!layer->polygon_tree)    layer->polygon_tree = r_create_tree (NULL, 0, 0);  r_insert_entry (layer->polygon_tree, (BoxType *)polygon, 0);  CLEAR_FLAG (NOCOPY_FLAGS | ExtraFlag, polygon);  return (polygon);}

/* --------------------------------------------------------------------------- * moves a line to buffer   */static void *MoveLineToBuffer (LayerType *layer, LineType *line){  LayerType *lay = &Dest->Layer[GetLayerNumber (Source, layer)];  RestoreToPolygon (Source, LINE_TYPE, layer, line);  r_delete_entry (layer->line_tree, (BoxType *)line);  layer->Line = g_list_remove (layer->Line, line);  layer->LineN --;  lay->Line = g_list_append (lay->Line, line);  lay->LineN ++;  CLEAR_FLAG (NOCOPY_FLAGS, line);  if (!lay->line_tree)    lay->line_tree = r_create_tree (NULL, 0, 0);  r_insert_entry (lay->line_tree, (BoxType *)line, 0);  ClearFromPolygon (Dest, LINE_TYPE, lay, line);  return (line);}

/* --------------------------------------------------------------------------- * moves an arc to buffer   */static void *MoveArcToBuffer (LayerType *layer, ArcType *arc){  LayerType *lay = &Dest->Layer[GetLayerNumber (Source, layer)];  RestoreToPolygon (Source, ARC_TYPE, layer, arc);  r_delete_entry (layer->arc_tree, (BoxType *)arc);  layer->Arc = g_list_remove (layer->Arc, arc);  layer->ArcN --;  lay->Arc = g_list_append (lay->Arc, arc);  lay->ArcN ++;  CLEAR_FLAG (NOCOPY_FLAGS, arc);  if (!lay->arc_tree)    lay->arc_tree = r_create_tree (NULL, 0, 0);  r_insert_entry (lay->arc_tree, (BoxType *)arc, 0);  ClearFromPolygon (Dest, ARC_TYPE, lay, arc);  return (arc);}

static IPTR mUse(struct IClass *cl, Object *obj, UNUSED Msg msg){    struct data            *data = INST_DATA(cl,obj);    struct URL_BrowserNode *bn = data->bn;    LONG                   i, visible, first;    CLEAR_FLAG(bn->ubn_Flags, UNF_NEW);    strlcpy(bn->ubn_Name, (STRPTR)xget(data->name,MUIA_String_Contents), sizeof(bn->ubn_Name));    strlcpy(bn->ubn_Path, (STRPTR)xget(data->path,MUIA_String_Contents), sizeof(bn->ubn_Path));    strlcpy(bn->ubn_Port, (STRPTR)xget(data->port,MUIA_String_Contents), sizeof(bn->ubn_Port));    strlcpy(bn->ubn_ShowCmd, (STRPTR)xget(data->show,MUIA_String_Contents), sizeof(bn->ubn_ShowCmd));    strlcpy(bn->ubn_ToFrontCmd, (STRPTR)xget(data->toFront,MUIA_String_Contents), sizeof(bn->ubn_ToFrontCmd));    strlcpy(bn->ubn_OpenURLCmd, (STRPTR)xget(data->openURL,MUIA_String_Contents), sizeof(bn->ubn_OpenURLCmd));    strlcpy(bn->ubn_OpenURLWCmd, (STRPTR)xget(data->openURLNW,MUIA_String_Contents), sizeof(bn->ubn_OpenURLWCmd));    visible = xget(data->browserList, MUIA_List_Visible);    if (visible!=-1)    {        first = xget(data->browserList, MUIA_List_First);        for (i = first; i < (first + visible); i++)        {            DoMethod(data->browserList,MUIM_List_GetEntry,i,(IPTR)&bn);            if (!bn) break;            if (bn==data->bn)            {                DoMethod(data->browserList,MUIM_List_Redraw,i);                break;            }        }    }    set(obj,MUIA_Window_CloseRequest,TRUE);    return TRUE;}