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

void sgen_run_generator(struct sgen_generator *g, struct codec *c, sample_t *buf, ssize_t frames){	sample_t s;	double t;	ssize_t i, k, samples;	switch (g->type) {	case SGEN_TYPE_DELTA:		if (g->offset >= 0) {			if (g->offset < frames)				for (i = 0; i < c->channels; ++i)					if (GET_BIT(g->channel_selector, i))						buf[g->offset * c->channels + i] += 1.0;			g->offset -= frames;		}		break;	case SGEN_TYPE_SINE:		samples = frames * c->channels;		for (i = 0; i < samples; i += c->channels) {			t = (double) g->pos / c->fs;			if (g->v != 0.0)				s = sin(g->freq0 / g->v * (exp(t * g->v) - 1.0));			else				s = sin(g->freq0 * t);			for (k = 0; k < c->channels; ++k)				if (GET_BIT(g->channel_selector, k))					buf[i + k] += s;			++g->pos;		}		break;	}}

/* * Boot module scope */intapp_preload(struct app_t *app, int argc, char **argv){	struct module_t *module = app->data;	struct app_opt_t *app_opt;	if(NULL == module)		return E_MOD;	app_opt = app->opts;	log(app->ctx,1,"app preload: %s/n", module->name);	/* Must be boot type */	if(!GET_BIT(module->type, M_BOOT))		return E_CONF;	if(!GET_BIT(module->type, M_EMBED))		log(app->ctx, 1, "Warn: app module not embedded!/n");	app->ctx->boot->module = module;	if(module->preload(app->ctx, app->ctx->boot))		return E_CONF;	/* Now register app and we are ready to go */	if(!register_app(app->ctx, app))		return E_CONF;	return E_NONE;}

/** * Calculates the heuristic score for the AI */heuristic_t calculate_heuristics(int isItSelfTurn) {    // Turn bonus    heuristic_t score = (isItSelfTurn << 3) - (isItSelfTurn << 1) - 3; //isItSelfTurn*6-3    // Material + king bonus    score += population_score();    // Runaway man    /*score += ((0x00000010 & (gamestate.self & (~gamestate.kings))) && !(0x00000001 & gamestate.occupied)) * 47;    score -= ((0x01000000 & (gamestate.other & (~gamestate.kings))) && !(0x30000000 & gamestate.occupied)) * 47;    score += ((0x00000020 & (gamestate.self & (~gamestate.kings))) && !(0x00000003 & gamestate.occupied)) * 47;    score -= ((0x02000000 & (gamestate.other & (~gamestate.kings))) && !(0x60000000 & gamestate.occupied)) * 47;    score += ((0x00000040 & (gamestate.self & (~gamestate.kings))) && !(0x00000006 & gamestate.occupied)) * 47;    score -= ((0x04000000 & (gamestate.other & (~gamestate.kings))) && !(0xC0000000 & gamestate.occupied)) * 47;    score += ((0x00000080 & (gamestate.self & (~gamestate.kings))) && !(0x0000000C & gamestate.occupied)) * 47;    score -= ((0x08000000 & (gamestate.other & (~gamestate.kings))) && !(0x80000000 & gamestate.occupied)) * 47;    score += ((0x00000100 & (gamestate.self & (~gamestate.kings))) && !(0x00000011 & gamestate.occupied)) * 44;    score -= ((0x00100000 & (gamestate.other & (~gamestate.kings))) && !(0x31000000 & gamestate.occupied)) * 44;    score += ((0x00000200 & (gamestate.self & (~gamestate.kings))) && !(0x00000067 & gamestate.occupied)) * 44;    score -= ((0x00200000 & (gamestate.other & (~gamestate.kings))) && !(0x73000000 & gamestate.occupied)) * 44;    score += ((0x00000400 & (gamestate.self & (~gamestate.kings))) && !(0x000000CE & gamestate.occupied)) * 44;    score -= ((0x00400000 & (gamestate.other & (~gamestate.kings))) && !(0xE6000000 & gamestate.occupied)) * 44;    score += ((0x00000800 & (gamestate.self & (~gamestate.kings))) && !(0x0000008C & gamestate.occupied)) * 44;    score -= ((0x00800000 & (gamestate.other & (~gamestate.kings))) && !(0x88000000 & gamestate.occupied)) * 44;*/    // Back row bonus    score += population_count(0xF0000000 & gamestate.occupied) * 7;    score -= population_count(0x0000000F & gamestate.occupied) * 7;    // Dog hole penalty    score += (GET_BIT(gamestate.other, 27) && GET_BIT(gamestate.self, 31)) * 10;    score -= (GET_BIT(gamestate.self, 4) && GET_BIT(gamestate.other, 0)) * 10;    return score;}

void compress_effect_run(struct effect *e, ssize_t *frames, sample_t *ibuf, sample_t *obuf){    ssize_t i, k, samples = *frames * e->ostream.channels;    sample_t s, gain_target;    struct compress_state *state = (struct compress_state *) e->data;    for (i = 0; i < samples; i += e->ostream.channels) {        s = 0;        for (k = 0; k < e->ostream.channels; ++k)            if (GET_BIT(e->channel_selector, k))                s = MAXIMUM(fabs(ibuf[i + k]), s);        if (s > state->thresh)            gain_target = pow(10, (state->thresh_db - (20 * log10(s))) * state->ratio / 20);        else            gain_target = 1.0;        if (state->gain > gain_target) {            state->gain *= state->attack;            if (state->gain < gain_target)                state->gain = gain_target;        }        else if (state->gain < gain_target) {            state->gain *= state->release;            if (state->gain > gain_target)                state->gain = gain_target;        }        for (k = 0; k < e->ostream.channels; ++k) {            if (GET_BIT(e->channel_selector, k))                obuf[i + k] = ibuf[i + k] * state->gain;            else                obuf[i + k] = ibuf[i + k];        }    }}

void controlBrakePostfire(int hasEventFlags, int craneKnownFlags,         int cranePresentFlags) {    switch(state) {        case READY : {            if(GET_BIT(craneKnownFlags, TRIGGERBIT)) {                if(GET_BIT(cranePresentFlags, TRIGGERBIT)) {                    state = RUNNING;                }            }        } break;        case RUNNING : {            if(GET_BIT(hasEventFlags, SHUTDOWNBIT)) {                initControlBrake();                break;            }            if(GET_BIT(craneKnownFlags, EMSTOPMERGERBIT)) {                if(GET_BIT(cranePresentFlags, EMSTOPMERGERBIT)) {                    initControlBrake();                }            }        } break;    }}

int key_pressed(r,c) {	if (!GET_BIT(PINC, r)) {		if (!GET_BIT(PORTC, c))		return 1;	}	return 0;}

Board captureLine(Board b, int moveIndex, int player, short dX, short dY) {	Board bc = b;	while ( 1 ) {		// Left side out of bounds		if( dX < 0 && moveIndex % 8 == 0) {			return b;		}		// Right side out of bounds		if ( dX > 0 && moveIndex % 8 == 7) {			return b;		}		moveIndex += dX + dY * 8;		// Upper edge & lower edge out of bounds		if ( moveIndex < 0 || moveIndex > 63 ) {			return b;		}		else if ( ! GET_BIT(b.mask, moveIndex) ) {			return b;		}		else if ( GET_BIT(b.owner, moveIndex) ^ player){			bc.owner = TOGGLE_BIT(bc.owner, moveIndex);		}		else {			return bc;		}	}	return b; // Never reached, included for compiler warnings}

/* returns 0 if bmsk and src dont match, 1 if they do */intconvCmp_bitMask(Byte bmsk, Byte src, int istart, int iend){    int ret = 1;    if (!iend) {        /* if there's only one index number to check (iend = 0) */	if (GET_BIT(bmsk, 0) != GET_BIT(src, istart)) {	    return 0;	}        else {            return 1;	}    }    /* if there's a group of index numbers to check */    else {	int i, x;        for (i = istart, x = 0; i < iend; i++, x++) {            if (GET_BIT(src, i) != GET_BIT(bmsk, x)) {                ret = 0;                break;            }        }    }    return ret;}

_Bool pressed(int col, int row){	CLR_BIT(PORTC, col);	_Bool buttonPressed = !GET_BIT(PINC, col) && !GET_BIT(PINC, row);		return !GET_BIT(PINC, col) && !GET_BIT(PINC, row);}

/* * Boot. * Squat app/module is using it */struct ctx_t *app_boot(struct ctx_t *cur, void *a, void *args){	app_getopt *opts = args;	struct app_t *app = a;	struct cfg_t *cfg;	if(NULL == cur)	{		if(app->ctx)			log(app->ctx, 1, "Alredy got app->ctx!/n");		app->ctx = ctx_new(CTX_STDERR|CTX_BOOT);		if (NULL == app->ctx)			return NULL;	}	else		app->ctx = cur;	cfg = app->ctx->cfg;	set_early_log(app->ctx);	/* Ok we really really need this very early */	if(NULL == sys_create(app->ctx, "api", T_HASH))		return NULL;	/*if(NULL == sys_create(app->ctx, "parser", T_STORE))		return NULL;*/	log(app->ctx, 0, "app boot: %s/n", app->name);	/*	 * Default handler is sig_run	 * sig_run is responsible of traversing ctx/scope	 * and run all handlers that are registered	 */	/*signal(SIGINT, sig_run);	signal(SIGHUP, sig_run);	signal(SIGTERM, sig_run);	signal(SIGSEGV, sig_run);	signal(SIGBUS, sig_run);*/	/* reset to default boot options */	if(GET_BIT(app->type, APP_DAEMON))		cfg->basic->daemon = 1;	if(GET_BIT(app->type, APP_LOG))		cfg->basic->prio = 1;	/* cfg */	cfg->basic->argc = opts->argc;	cfg->basic->argv = opts->argv;	optind = 1;	return app->ctx;}

static void rewrite_source(struct radeon_compiler * c,		struct rc_instruction * inst, unsigned src){	struct rc_swizzle_split split;	unsigned int tempreg = rc_find_free_temporary(c);	unsigned int usemask;	usemask = 0;	for(unsigned int chan = 0; chan < 4; ++chan) {		if (GET_SWZ(inst->U.I.SrcReg[src].Swizzle, chan) != RC_SWIZZLE_UNUSED)			usemask |= 1 << chan;	}	c->SwizzleCaps->Split(inst->U.I.SrcReg[src], usemask, &split);	for(unsigned int phase = 0; phase < split.NumPhases; ++phase) {		struct rc_instruction * mov = rc_insert_new_instruction(c, inst->Prev);		unsigned int phase_refmask;		unsigned int masked_negate;		mov->U.I.Opcode = RC_OPCODE_MOV;		mov->U.I.DstReg.File = RC_FILE_TEMPORARY;		mov->U.I.DstReg.Index = tempreg;		mov->U.I.DstReg.WriteMask = split.Phase[phase];		mov->U.I.SrcReg[0] = inst->U.I.SrcReg[src];		mov->U.I.PreSub = inst->U.I.PreSub;		phase_refmask = 0;		for(unsigned int chan = 0; chan < 4; ++chan) {			if (!GET_BIT(split.Phase[phase], chan))				SET_SWZ(mov->U.I.SrcReg[0].Swizzle, chan, RC_SWIZZLE_UNUSED);			else				phase_refmask |= 1 << GET_SWZ(mov->U.I.SrcReg[0].Swizzle, chan);		}		phase_refmask &= RC_MASK_XYZW;		masked_negate = split.Phase[phase] & mov->U.I.SrcReg[0].Negate;		if (masked_negate == 0)			mov->U.I.SrcReg[0].Negate = 0;		else if (masked_negate == split.Phase[phase])			mov->U.I.SrcReg[0].Negate = RC_MASK_XYZW;	}	inst->U.I.SrcReg[src].File = RC_FILE_TEMPORARY;	inst->U.I.SrcReg[src].Index = tempreg;	inst->U.I.SrcReg[src].Swizzle = 0;	inst->U.I.SrcReg[src].Negate = RC_MASK_NONE;	inst->U.I.SrcReg[src].Abs = 0;	for(unsigned int chan = 0; chan < 4; ++chan) {		SET_SWZ(inst->U.I.SrcReg[src].Swizzle, chan,				GET_BIT(usemask, chan) ? chan : RC_SWIZZLE_UNUSED);	}}

void perm_to_str(int perm, char str[4]){    strcpy(str, "rwx");    if(GET_BIT(perm, 2) == 0)        str[0] = '-';    if(GET_BIT(perm, 1) == 0)        str[1] = '-';    if(GET_BIT(perm, 0) == 0)        str[2] = '-';}

int read_pagemap(char * path_buf, unsigned long virt_addr){   printf("Big endian? %d/n", is_bigendian());   f = fopen(path_buf, "rb");   if(!f){      printf("Error! Cannot open %s/n", path_buf);      return -1;   }      //Shifting by virt-addr-offset number of bytes   //and multiplying by the size of an address (the size of an entry in pagemap file)   file_offset = virt_addr / getpagesize() * PAGEMAP_ENTRY;   printf("Vaddr: 0x%lx, Page_size: %d, Entry_size: %d/n", virt_addr, getpagesize(), PAGEMAP_ENTRY);   printf("Reading %s at 0x%llx/n", path_buf, (unsigned long long) file_offset);   status = fseek(f, file_offset, SEEK_SET);   if(status){      perror("Failed to do fseek!");      return -1;   }   errno = 0;   read_val = 0;   unsigned char c_buf[PAGEMAP_ENTRY];   for(i=0; i < PAGEMAP_ENTRY; i++){      c = getc(f);      if(c==EOF){         printf("/nReached end of the file/n");         return 0;      }      if(is_bigendian())           c_buf[i] = c;      else           c_buf[PAGEMAP_ENTRY - i - 1] = c;      printf("[%d]0x%x ", i, c);   }   for(i=0; i < PAGEMAP_ENTRY; i++){      //printf("%d ",c_buf[i]);      read_val = (read_val << 8) + c_buf[i];   }   printf("/n");   printf("Result: 0x%llx/n", (unsigned long long) read_val);   //if(GET_BIT(read_val, 63))   if(GET_BIT(read_val, 63))      printf("PFN: 0x%llx/n",(unsigned long long) GET_PFN(read_val));   else      printf("Page not present/n");   if(GET_BIT(read_val, 62))      printf("Page swapped/n");   fclose(f);   return 0;}

static void plot_rfi(rfi * plotrfi, float top, int numint, int numchan,                     float T, float lof, float hif){   int ii;   float period, perioderr, dy = 0.035, *temparr;   float tr[6] = { -0.5, 1.0, 0.0, -0.5, 0.0, 1.0 };   char temp[40];   if (plotrfi->freq_avg == 0.0)      period = 0.0;   else      period = 1000.0 / plotrfi->freq_avg;   if (plotrfi->freq_var == 0.0)        /* Why are these zero? */      perioderr = 0.0;   else      perioderr = 1000.0 * sqrt(plotrfi->freq_var) /          (plotrfi->freq_avg * plotrfi->freq_avg);   cpgsvp(0.0, 1.0, 0.0, 1.0);   cpgswin(0.0, 1.0, 0.0, 1.0);   cpgnice_output_2(temp, plotrfi->freq_avg, sqrt(plotrfi->freq_var), 0);   cpgptxt(0.03, top - 0.6 * dy, 0.0, 0.0, temp);   cpgnice_output_2(temp, period, perioderr, 0);   cpgptxt(0.12, top - 0.6 * dy, 0.0, 0.0, temp);   sprintf(temp, "%-5.2f", plotrfi->sigma_avg);   cpgptxt(0.21, top - 0.6 * dy, 0.0, 0.0, temp);   sprintf(temp, "%d", plotrfi->numobs);   cpgptxt(0.27, top - 0.6 * dy, 0.0, 0.0, temp);   ii = (numint > numchan) ? numint : numchan;   temparr = gen_fvect(ii);   for (ii = 0; ii < numchan; ii++)      temparr[ii] = GET_BIT(plotrfi->chans, ii);   cpgsvp(0.33, 0.64, top - dy, top);   cpgswin(0.0, numchan, 0.0, 1.0);   cpgimag(temparr, numchan, 1, 1, numchan, 1, 1, 0.0, 1.0, tr);   cpgswin(0.0, numchan, 0.0, 1.0);   cpgbox("BST", 0.0, 0, "BC", 0.0, 0);   cpgswin(lof, hif, 0.0, 1.0);   cpgbox("CST", 0.0, 0, "", 0.0, 0);   for (ii = 0; ii < numint; ii++)      temparr[ii] = GET_BIT(plotrfi->times, ii);   cpgsvp(0.65, 0.96, top - dy, top);   cpgswin(0.0, numint, 0.0, 1.0);   cpgimag(temparr, numint, 1, 1, numint, 1, 1, 0.0, 1.0, tr);   cpgswin(0.0, numint, 0.0, 1.0);   cpgbox("BST", 0.0, 0, "BC", 0.0, 0);   cpgswin(0.0, T, 0.0, 1.0);   cpgbox("CST", 0.0, 0, "", 0.0, 0);   vect_free(temparr);}

int preprocess_it(Instruction *out, Emulator *emul){	char msk = (char) out->ext.plages[0].value;	int mask=0, sign=0, thn=out->ext.plages[1].value, els=0;	int i, k;	char cond0 = GET_BIT(thn, 0);	for (k = 0; k < 4; k++) // trouve le premier bit à 1	{		if(GET_BIT(msk, k) == (1 << k) )			break;	}	for (i = 3; i > k; i--)	{		if( GET_BIT(msk, i) == (cond0 << i) )		{			strcat(out->name_out, "T");			sign += (sign << 1) + 1;		}		else		{			strcat(out->name_out, "E");			sign <<= 1;		}	}	strcat(out->name_out, " ");	strcat(out->name_out, emul->dic->states_tab[thn]);	mask = (1 << (4 - k)) - 1; // mask au format de la fonction process_state	sign += (sign << 1) + 1; // la première condition est forcément Then	// printf("k = %u/tmask = %s/n", k, int_to_bin(mask, 4));	if( (thn & 1) == 0 )		els = thn + 1;	else		els = thn - 1;	set_it_state(&emul->it_state, mask, sign, thn, els);	return 0;}

// Encodes a frame according to the following rule:// First byte : Start sequence = 1111 1111 (0xFF)// Second byte : Total size of the encoded frame// The starting sequence cannot be repeated in the rest of the encoded frame, so// a 0 (zero) is interleaved every 7 consecutive 1s (ex: 1111 1111 is encoded to 1111 1110 1000)uint8_t * DataLinkLayer::frame_encode(Frame * frame, uint8_t * size) {    uint8_t * data = (uint8_t *) frame;    uint32_t consecutive_ones = 0;    uint32_t total_extra_bits = 0;    uint32_t bit_number = 0;    // Calculate the necessary extra bits to encode the frame    for(int i = 0; i < sizeof(*frame) * 8; i++) {        if (GET_BIT(data, i)) {            consecutive_ones++;            if (consecutive_ones == 8) {                total_extra_bits++;                consecutive_ones = 1;            }        } else {            consecutive_ones = 0;        }    }    // Allocate the necessary space for the encoded frame    // The size the total size of the frame plus the necessary bytes for the extra bits    uint32_t alloc_size = sizeof(*frame) + (total_extra_bits ? (total_extra_bits / 8) + 1 : 0);    uint8_t * result = (uint8_t *) calloc(alloc_size + 2, sizeof(uint8_t));    // Set the frame start byte    *result = FRAME_START_BYTE;    // Set the total allocation size    *(result + 1) = alloc_size;    consecutive_ones = 0;    // Encodes the frame interleaving a zero every 7 consecutive ones    for(int i = 0; i < sizeof(*frame) * 8; i++, bit_number++) {        uint8_t current_bit = GET_BIT(data, i);        if (current_bit) {            consecutive_ones++;            if (consecutive_ones == 8) {                bit_number++;                consecutive_ones = 1;            }        } else {            consecutive_ones = 0;        }        *(result + 2 + (bit_number / 8)) |= (current_bit << (8 - (bit_number % 8) - 1));    }    *size = alloc_size + 2;    return result;}

static void reads_normal(struct rc_instruction * fullinst, rc_read_write_fn cb, void * userdata){	struct rc_sub_instruction * inst = &fullinst->U.I;	const struct rc_opcode_info * opcode = rc_get_opcode_info(inst->Opcode);	for(unsigned int src = 0; src < opcode->NumSrcRegs; ++src) {		unsigned int refmask = 0;		if (inst->SrcReg[src].File == RC_FILE_NONE)			return;		for(unsigned int chan = 0; chan < 4; ++chan)			refmask |= 1 << GET_SWZ(inst->SrcReg[src].Swizzle, chan);		refmask &= RC_MASK_XYZW;		for(unsigned int chan = 0; chan < 4; ++chan) {			if (GET_BIT(refmask, chan)) {				cb(userdata, fullinst, inst->SrcReg[src].File, inst->SrcReg[src].Index, chan);			}		}		if (refmask && inst->SrcReg[src].RelAddr)			cb(userdata, fullinst, RC_FILE_ADDRESS, 0, RC_MASK_X);	}}

status_tsubmit_tx_command(bt_usb_dev* bdev, snet_buffer* snbuf){	uint8 bRequestType = bdev->ctrl_req;	uint8 bRequest = 0;	uint16 wIndex = 0;	uint16 value = 0;	uint16 wLength = B_HOST_TO_LENDIAN_INT16(snb_size(snbuf));	status_t error;	if (!GET_BIT(bdev->state, RUNNING)) {		return B_DEV_NOT_READY;	}	// set cookie	snb_set_cookie(snbuf, bdev);	debugf("@%p/n", snb_get(snbuf));	error = usb->queue_request(bdev->dev, bRequestType, bRequest,		value, wIndex, wLength,	snb_get(snbuf),#ifndef HAIKU_TARGET_PLATFORM_HAIKU		wLength,#endif		command_complete, (void*) snbuf);	if (error != B_OK) {		bdev->stat.rejectedTX++;	} else {		bdev->stat.acceptedTX++;	}	return error;}

status_tsubmit_tx_acl(bt_usb_dev* bdev, net_buffer* nbuf){	status_t error;	// set cookie	SET_DEVICE(nbuf, bdev->hdev);	if (!GET_BIT(bdev->state, RUNNING)) {		return B_DEV_NOT_READY;	}	/*	debugf("### Outgoing ACL: len = %ld/n", nbuf->size);	for (uint32 index = 0 ; index < nbuf->size; index++ ) {		dprintf("%x:",((uint8*)nb_get_whole_buffer(nbuf))[index]);	}	*/	error = usb->queue_bulk(bdev->bulk_out_ep->handle, nb_get_whole_buffer(nbuf),		nbuf->size, acl_tx_complete, (void*)nbuf);	if (error != B_OK) {		bdev->stat.rejectedTX++;	} else {		bdev->stat.acceptedTX++;	}	return error;}

/**********************************************************************************函数功能：点亮或者熄灭某一个显示标志入口：    Flag----1:显示;0:熄灭出口：    1---------有此设备；0------找不到设备**********************************************************************************/INT8U SetOrClr_COM4(INT16U Seg,INT8U Com,INT8U Type,INT8U ClrOrSet){     if((Seg<=MAX_SEG)&&(Com<=MAX_COL))  {    Com=MAX_COL-Com;    if(Seg%2 EQ 0)       //高4位        Com+=MAX_COL+1;          if(ClrOrSet)    {      if(GET_BIT(Show_Lcd_Ram[Seg/2],Com))  //检查内存是否已经置位或者 seg/com配置表错误      return 0;            Show_Lcd_Flag=1;                   SET_BIT(Show_Lcd_Ram[Seg/2],Com);      return 1;    }    else    {              CLR_BIT(Show_Lcd_Ram[Seg/2],Com);      return 1;    }    }  return 0;}

int main(void){	DDRA = 0xFF; //set all pins of port A to output	DDRC = 0x00; //set all pins of port C to input	while(1)	{		int one = 1;		int count = 0;		int i = 0;		while(i < 8)		{			int temp = GET_BIT(PINC,i);			if(temp != 0)			{				count++;			}			++i;		}		if ((count % 2) != 0)		{			CLR_BIT(PORTA, 1);			one = SET_BIT(PORTA, 0);		}		else 		{				CLR_BIT(PORTA, 0);			one = SET_BIT(PORTA, 1);		}		count = 0;	}return 0;	}

static int kernel_call_dispatch(struct proc * caller, message *msg){  int result = OK;  int call_nr;  #if DEBUG_IPC_HOOK	hook_ipc_msgkcall(msg, caller);#endif  call_nr = msg->m_type - KERNEL_CALL;  /* See if the caller made a valid request and try to handle it. */  if (call_nr < 0 || call_nr >= NR_SYS_CALLS) {	/* check call number */	  printf("SYSTEM: illegal request %d from %d./n",			  call_nr,msg->m_source);	  result = EBADREQUEST;			/* illegal message type */  }  else if (!GET_BIT(priv(caller)->s_k_call_mask, call_nr)) {	  printf("SYSTEM: denied request %d from %d./n",			  call_nr,msg->m_source);	  result = ECALLDENIED;			/* illegal message type */  } else {	  /* handle the system call */	  if (call_vec[call_nr])		  result = (*call_vec[call_nr])(caller, msg);	  else {		  printf("Unused kernel call %d from %d/n",				  call_nr, caller->p_endpoint);		  result = EBADREQUEST;	  }  }  return result;}

int mrpc_bitmap_acquire_bit(struct mrpc_bitmap *bitmap){	uint64_t *map;	int i;	int n;	int bitmap_size;	ff_assert(bitmap->size > 0);	ff_assert(bitmap->last_free_bit < bitmap->size);	map = bitmap->map;	n = bitmap->last_free_bit;	bitmap_size = bitmap->size;	for (i = 0; i < bitmap_size; i++)	{		if (GET_BIT(map, n) == 0)		{			SET_BIT(map, n);			bitmap->last_free_bit = n;			break;		}		n++;		if (n == bitmap_size)		{			n = 0;		}	}	if (i == bitmap_size)	{		ff_log_debug(L"all bits are occupied in the bitmap=%p", bitmap);		n = -1;	}	return n;}

void huffmanDecode(FILE *in, FILE *out, CODIFICATION_ARRAY_ELEMENT *treeArray, SYMBOL eof) {	uint8_t feof = 0;	unsigned int index = 0;	for(unsigned int i = 0 ; !feof ; i++) {		BYTE buffer;		fread(&buffer, 1, 1, in);		for(unsigned int j = 0 ; j < BYTE_BIT ; j++) {			index <<= 1;			if((GET_BIT(&buffer, j)) == 0)				index += 1;			else				index += 2;			if(treeArray[index].used) {				if(treeArray[index].symbol == eof) {					feof = 1;					return;				}				else					fwrite(&treeArray[index].symbol, SIZEOF_SYMBOL, 1, out);				index = 0;			}		}	}}

/** * Make a transition from <currentState> to the next state for a bit vector encoded * as a single integer (max. 64 genes). * <currentState> is a binary-coded integer with <numberOfGenes> used bits. * <fixedGenes> is an array of values specifying whether gene <i> is fixed (0 or 1) or not (-1). * <inputGenes> provides the input genes for all transition functions and can be split up * for a single function according to <inputGenePositions>. * <transitionFunctions> provides the truth tables for all transition functions and can be split up * for a single function according to <transitionFunctionPositions>. * * The return value is the next state, encoded in a single integer. */unsigned long long stateTransition_singleInt(unsigned long long currentState, TruthTableBooleanNetwork * net){	unsigned int i = 0, k = 0, idx = 0;  unsigned long long nextState = 0;	for (i = 1; i <= net->numGenes; ++i)	{		if (net->fixedGenes[i-1] == -1)		// the gene is not fixed		{			unsigned long long inputdec = 0;			for (k = net->inputGenePositions[i-1]; k < net->inputGenePositions[i]; k++)			{				if (net->inputGenes[k])				// if the input of the function is not 0 (constant gene), take input bit				{					unsigned int gene = net->inputGenes[k] - 1;					unsigned int bit;					if (net->fixedGenes[gene] == -1)						bit = (GET_BIT(currentState,							     net->nonFixedGeneBits[gene]));					else						// fixed genes are not encoded in the states						// => take them from fixedGenes vector						bit = net->fixedGenes[gene];					inputdec |= bit	<< (net->inputGenePositions[i] - k - 1);				}			}			// determine transition function			int transition = net->transitionFunctions[net->transitionFunctionPositions[i-1] + inputdec];			if(transition != -1)				// apply transition function				nextState |= (transition << idx);			else				// this is a dummy function for a constant gene				// => value does not change				nextState |= (GET_BIT(currentState,															idx) << idx);			++idx;		}	}	return nextState;}

/* * Calculate the cpu speed based on the PLL, if the PLL * is not being used, this function will return 0 */unsigned longa7hal_clock_getFreq (int noRAM){  unsigned int freq = 0;#if defined(A7VE) || defined(A7VC) || defined(A7VT) || defined(A7VL)  unsigned long feedbackDivider;  unsigned long outputDivider;  unsigned long referenceDivider;#else  unsigned int scale;#endif  if (GET_BIT (SYS_CLOCK_CONTROL_REG, CLK_SEL_BIT))    {      if (GET_BIT (SYS_CLOCK_CONTROL_REG, PLL_SEL_BIT))	{#if defined(A7VE) || defined(A7VC) || defined(A7VT) || defined(A7VL)	  feedbackDivider = GET_FIELD (SYS_PLL_CONTROL_REG,				       PLL_CLKF_FIELD, NBITS_PLL_CLKF) + 1;	  outputDivider = GET_FIELD (SYS_PLL_CONTROL_REG,				     PLL_CLKOD_FIELD, NBITS_PLL_CLKOD) + 1;	  referenceDivider = GET_FIELD (SYS_PLL_CONTROL_REG,					PLL_CLKR_FIELD, NBITS_PLL_CLKR) + 1;          /*           * Is the input to the PLL the 32KHz xtal or the external osc.           */          if ( GET_BIT( SYS_PLL_CONTROL_REG, PLL_REFSEL_BIT ) )          {            freq = ( CONFIG_OSC_FREQ * feedbackDivider ) /                ( referenceDivider * outputDivider );          }          else          {              freq = ( 32768 * feedbackDivider ) /                  ( referenceDivider * outputDivider );          }#else	  freq = 32768 * GET_FIELD (SYS_CLOCK_CONTROL_REG,				    PLL_DIV_FIELD, NBITS_PLL_DIV);	  scale =	    GET_FIELD (SYS_CLOCK_CONTROL_REG, PLL_SCALE_FIELD,		       NBITS_PLL_SCALE);	  while (scale)	    {	      freq >>= 1;	      scale >>= 1;	    }#endif	}      else	{	  freq = CONFIG_OSC_FREQ;	}    }

void mrpc_bitmap_release_bit(struct mrpc_bitmap *bitmap, int n){	ff_assert(bitmap->size > 0);	ff_assert(n < bitmap->size);	ff_assert(GET_BIT(bitmap->map, n) == 1);	CLEAR_BIT(bitmap->map, n);}

int GetNextTweet(DatabaseItr* itr, Tweet* dest){    do {        if(ReadTweet(itr->data, dest) < 0) return -1;    } while(GET_BIT(dest->flags, ACTIVE_BIT) == 0);    return 0;}