void IDLMRecord::IsDoOnce(bool value) { SETBIT(IDLF.value, fIsDoOnce, value); }
void WRLDRecord::IsNeedsWaterAdjustment(bool value) { SETBIT(PNAM.value, fIsNeedsWaterAdjustment, value); }
void main(void){ __disable_interrupt(); //Anolog mux channel select output DDRA = 0x3B; DDRB = 0xFF; //initialize LCD SETBIT(PORTB, 0); //deselect slave init_lcd_dog(); clear_dsp(); DDRD = 0x01; // initialize PortD for interrupt PORTD = 0x02; SETBIT(DDRD, 7); //enable buzzer output SETBIT(PORTD, 7); //disable buzzer EIMSK = 0x0F; // enable individual interrupt EICRA = 0x53; __enable_interrupt(); //infinite loop -- approximately 1 second for each loop while(1){ if(present_state == Limit){ __EEGET(temp_limit,channel_display); if(flag & (1 << 0)){ temp_int = ((signed int)(temp_limit)*9)/5 + 32; unit_temp = 'F'; }else{ temp_int = (signed int)temp_limit; unit_temp = 'C'; } clear_dsp(); printf("Limit: %d ",temp_int); putchar(unit_temp); update_lcd_dog(); }else{ for(channel_conv = 0; channel_conv < 8; channel_conv++){ DG528_driver(channel_conv); //select channel for(i = 0; i < 10; i++){ //conv for each channel 10 times channel_voltage[channel_conv][i%8] = ADC161_conv(); } } if(present_state == Auto){ if(current_time == 3){ current_time = 0; //reset timer; channel_display = (channel_display + 1)%8; }else current_time ++ ; }else current_time = 0; //always reset timer on man state if(present_state == Alert && counter == 0) CLEARBIT(PORTD, 7); else{ SETBIT(PORTD, 7); if(counter > 0) counter --; } //summing ADC reading for a particular channel adc_sum = 0; for(i = 0; i<8; i++) adc_sum += (unsigned long int)channel_voltage[channel_display][i]; //average the sum and look up the temperature in the table temperature = tb_lookup(((unsigned int)(adc_sum >> 3))); if(flag & (1 << 0)){ temperature = (temperature* 9)/5 + 320; unit_temp = 'F'; }else unit_temp = 'C'; if(temperature < 0) temp_tenth = (0 - temperature)%10; else temp_tenth = temperature%10; temperature = temperature/10; clear_dsp(); printf("%s: %d.%d ", a[channel_display], temperature, temp_tenth); putchar(unit_temp); update_lcd_dog(); __EEGET(temp_limit, channel_display); if(flag & (1 << 0)) temp_int = ((signed int)(temp_limit)*9)/5 + 32; else temp_int = (signed int)temp_limit; if(((temp_int != 0) && (temp_int <= temperature)) || present_state == Alert) { index = 16; printf("LIMIT EXCEEDED!!"); update_lcd_dog(); SETBIT(PORTD, 0); CLEARBIT(PORTD, 0); } __delay_cycles(8000000); //delay_for_1 second } } }
void WRLDRecord::IsNoLODWater(bool value) { SETBIT(DATA.value, fIsNoLODWater, value); }
void WRLDRecord::IsUseClimateData(bool value) { SETBIT(PNAM.value, fIsUseClimateData, value); }
void bfilter_add(const bloom_filter* bFilter, const unsigned* input) { SETBIT(bFilter->filter, *input % bFilter->num_buckets); }
int dht_get(void) { int res; sample_count++; if(sample_count < DHT_INTERVAL) { return FALSE; } sample_count = 0; DPUTS(label); DPUTS("read "); DPUTS("start"); DCR; SETBIT(DHT_DDR, DHT_PIN); /* set to output */ CLEARBIT(DHT_OUTP, DHT_PIN); /* output low */ /* This might need to be adjusted for dht11 and 22 * Longer delay (50ms) seems to work fine on 11, but not 22. */ _delay_ms(20); /* min 18ms */ SETBIT(DHT_OUTP, DHT_PIN); /* and high */ CLEARBIT(DHT_DDR, DHT_PIN); /* set for input */ /* set up prescalar for timer0 */ DHT_PRESCALE_REG |= \ (DHT_CS00 << CS00) | \ (DHT_CS01 << CS01) | \ (DHT_CS02 << CS02); if((res = dht_wait_for_value(0, DHT_FORTY)) > DHT_FORTY) { DPUTS(label); DPUTS("fail:"); DPUTS("0"); DCR; return FALSE; } if((res = dht_wait_for_value(1, DHT_HUNDRED)) > DHT_HUNDRED) { DPUTS(label); DPUTS("fail:"); DPUTS("1"); DCR; return FALSE; } if(dht_wait_for_value(0, DHT_HUNDRED) > DHT_HUNDRED) { DPUTS(label); DPUTS("fail:"); DPUTS("2"); DCR; return FALSE; } for(int i=0; i<5; i++) { for(int j=0; j<8; j++) { if(dht_wait_for_value(1, DHT_EIGHTY) > DHT_EIGHTY) { DPUTS(label); DPUTS("fail:"); DPUTS("3"); DCR; return FALSE; } if(dht_wait_for_value(0, DHT_EIGHTY) > DHT_FORTY) { SETBIT(dht_data[i], 7-j); } else { CLEARBIT(dht_data[i], 7-j); } } } /* should check the checksum */ uint8_t data = dht_data[0] + dht_data[1] + \ dht_data[2] + dht_data[3]; if (data != dht_data[4]) { DPUTS(label); DPUTS("fail:"); DPUTS("4"); DCR; return FALSE; } DPUTS(label); for(int i=0; i<5; i++) { DPUTBYTEX(dht_data[i]); DPUTS(" "); } DCR; /* /\* DHT11 format *\/ */ /* if(DHT_SENSOR_MODEL == SENSOR_MODEL_DHT11) { */ /* DPRINTF("Humidity: %0d.%02d percent\n\r", dht_data[0], dht_data[1]); */ /* DPRINTF("Temperature: %0d.%02d degrees C\n\r", dht_data[2], dht_data[3]); */ /* } */ /* if(DHT_SENSOR_MODEL == SENSOR_MODEL_DHT22) { */ /* uint16_t h, t; */ /* h = dht_data[0] << 8 | dht_data[1]; */ /* t = dht_data[2] << 8 | dht_data[3]; */ /* /\* DHT22 (tenths) *\/ */ /* DPRINTF("Hum: %0.2f\n\r", (float)h/10.0); */ /* DPRINTF("Temp: %0.2f\n\r", ((float)t/10.0) * (9.0/5.0) + 32); */ /* } */ DPUTS(label); DPUTS("read "); DPUTS("end"); DCR; return TRUE; }
void IPCTRecord::IsObjectParallax(bool value) { if (!DODT.IsLoaded()) return; SETBIT(DODT->flags, fIsParallax, value); }
void IPCTRecord::IsObjectAlphaTesting(bool value) { if (!DODT.IsLoaded()) return; SETBIT(DODT->flags, fIsAlphaTesting, value); }
void PGRERecord::IsPopIn(bool value) { if(!XESP.IsLoaded()) return; SETBIT(XESP->flags, fIsPopIn, value); }
void IPCTRecord::IsNoDecalData(bool value) { if (!DATA.IsLoaded()) return; SETBIT(DATA->flags, fIsNoDecalData, value); }
void PGRERecord::IsOppositeParent(bool value) { if(!XESP.IsLoaded()) return; SETBIT(XESP->flags, fIsOppositeParent, value); }
/*! * \brief Tag messages in the board * \param[in] node address of CommQueue node * \return Return Code * * This routine is to be executed during the firs communication stage * (::MB_COMM_OLD_PRE_TAGGING). * * Pre: * - node->mb is valid * - board->locked == ::MB_TRUE * - board->syncCompleted == ::MB_FALSE * - node->stage == ::MB_COMM_OLD_PRE_TAGGING * - node->flag_fdrFallback = ::MB_FALSE * - node->flag_shareOutbuf = ::MB_FALSE * - node->incount == \c NULL * - node->outcount == \c NULL * - node->inbuf == \c NULL * - node->outbuf == \c NULL * - node->sendreq == \c NULL * - node->recvreq == \c NULL * - node->board == \c NULL * * Steps: * -# Get pointer to board object and cache it in node->board * -# Allocate memory for node->outcount * -# If node->mb->filter == \c NULL or node->board->data->count_current = 0 * -# set node->outcount[*] = node->board->data->count_current * -# set node->flag_shareOutbuf = ::MB_TRUE * -# If node->board->filter != \c NULL * -# Use node->board->filter to build tag table in node->board->tt * -# Allocate memory for node->outcount * -# Initialise values in node->outcount[] based on contents of node->board->tt. * Keep count of outcount total as we go along. If total > node->board->data->count_current, * fallback to full data replication * - clear tag table * - set node->outcount[*] = node->board->data->count_current * - set node->flag_fdrFallback = ::MB_TRUE * - set node->flag_shareOutbuf = ::MB_TRUE * -# set node->stage to ::MB_COMM_OLD_READY_FOR_PROP * * Post: * - node->stage == ::MB_COMM_OLD_READY_FOR_PROP * - node->outcount != \c NULL * - node->board != \c NULL * - if (node->board->filter != NULL) * - if (node->flag_fdrFallback == ::MB_TRUE) node->board->tt == \c NULL * - if (node->flag_fdrFallback == ::MB_FALSE) node->board->tt != \c NULL * - if node->board->filter == \c NULL or node->fdr_fallback == \c ::MB_TRUE * - node->flag_shareOutbuf == ::MB_TRUE */ int MBI_CommRoutine_OLD_TagMessages(struct MBIt_commqueue *node) { char window; int rc, i, j, c, w, p; int total_tagged, mcount; void *msg; MBIt_TagTable *tt; pl_address_node *pl_itr; /* check that initial values are set properly */ assert(node->stage == MB_COMM_OLD_PRE_TAGGING); assert(node->flag_fdrFallback == MB_FALSE); assert(node->flag_shareOutbuf == MB_FALSE); assert(node->incount == NULL); assert(node->outcount == NULL); assert(node->inbuf == NULL); assert(node->outbuf == NULL); assert(node->recvreq == NULL); assert(node->sendreq == NULL); assert(node->board == NULL); /* get reference to board object and cache ptr in node */ node->board = (MBIt_Board *)MBI_getMBoardRef(node->mb); assert(node->board != NULL); if (node->board == NULL) return MB_ERR_INVALID; P_INFO("COMM: Preparing (Board %d) for sync process", node->mb); /* check board state */ assert(node->board->locked == MB_TRUE); assert(node->board->syncCompleted == MB_FALSE); /* get message count */ /* ignore messages that have already been synced */ mcount = (int)node->board->data->count_current - (int)node->board->synced_cursor; /* allocate memory for outcount */ node->outcount = (int *)calloc((size_t)MBI_CommSize, sizeof(int)); assert(node->outcount != NULL); if (node->outcount == NULL) return MB_ERR_MEMALLOC; /* determined number of messages to send to remote procs */ if (mcount == 0 || MBI_CommSize == 1) /* nothing to send */ { /* outcount already initialised to 0 (calloc) */ /*for (i = 0; i < MBI_CommSize; i++) node->outcount[i] = 0;*/ } else if (node->board->filter == (MBIt_filterfunc)NULL) /* no filter */ { /* send all messages to all procs (except self) */ for (i = 0; i < MBI_CommSize; i++) { node->outcount[i] = (i == MBI_CommRank) ? 0 : mcount; } /* outgoing buffer can be shared */ node->flag_shareOutbuf = MB_TRUE; } else /* filter assigned */ { P_INFO("COMM: (Board %d) is filtered. Tagging messages", (int)node->mb); /* create tag_table and assign to board */ rc = tt_create(&tt, mcount, MBI_CommSize); assert(rc == TT_SUCCESS); if (rc != TT_SUCCESS) { if (rc == TT_ERR_MEMALLOC) return MB_ERR_MEMALLOC; else return MB_ERR_INTERNAL; } node->board->tt = tt; /* assign to board */ /* initialise counters */ i = j = 0; total_tagged = 0; /* loop thru messages and fill up tag table */ for (pl_itr = PL_ITERATOR(node->board->data); pl_itr; pl_itr = pl_itr->next) { assert(i < (int)node->board->data->count_current); /* skip messages that have already been synced */ if (i < (int)node->board->synced_cursor) { i++; continue; } /* get reference to message from iterator */ msg = PL_NODEDATA(pl_itr); assert(msg != NULL); if (msg == NULL) return MB_ERR_INTERNAL; /* c : offset within byte buffer (window) * w : window offset within table row */ c = w = 0; SETZEROS(window); /* run filter on message per MPI task */ for (p = 0; p < MBI_CommSize; p++) { if (p != MBI_CommRank) { /* if message accepted by filter */ if (1 == (*node->board->filter)(msg, p)) { /* set bit within our byte buffer */ SETBIT(window, c); /* update outcount */ node->outcount[p]++; total_tagged++; } } /* move index within window */ c++; /* when window full, write to table and shift window */ if (c == 8) { /* write byte buffer to table */ rc = tt_setbyte(node->board->tt, j, w, window); assert(rc == TT_SUCCESS); /* move window */ w += 1; /* reset byte buffer */ SETZEROS(window); c = 0; } } /* write remaining byte buffer */ if (w < (int)node->board->tt->row_size) { rc = tt_setbyte(node->board->tt, j, w, window); assert(rc == TT_SUCCESS); } /* increment counter */ i++; j++; } assert(node->outcount[MBI_CommRank] == 0); /* Should we fall back to full data replication? */ if (total_tagged > mcount) { P_INFO("COMM: (Board %d) Tagged messages <%d> exceeds message count <%d>. " "Delegating filtering to recipient", (int)node->mb, total_tagged, mcount); /* we don't need the tagtable any more */ node->board->tt = NULL; rc = tt_delete(&tt); assert(rc == TT_SUCCESS); /* send all messages to all remote procs */ node->flag_fdrFallback = MB_TRUE; /* fallback to full data replication */ node->flag_shareOutbuf = MB_TRUE; /* use shared buffer */ for (i = 0; i < MBI_CommSize; i++) { if (node->outcount[i] != 0) node->outcount[i] = mcount; } } } /* move on to next stage */ P_INFO("COMM: (Board %d) moving to MB_COMM_OLD_READY_FOR_PROP stage", node->mb); node->stage = MB_COMM_OLD_READY_FOR_PROP; return MB_SUCCESS; }
void IDLMRecord::IsRunInSequence(bool value) { SETBIT(IDLF.value, fIsRunInSequence, value); }
uint32_t testAudioLineIn(void) { uint32_t rtn = ERR_NO_ERROR; int16_t msec, sec, sample; int32_t dat; // enable the audio clocks, verifying each bit is properly set. SETBIT(MCASP->XGBLCTL, XHCLKRST); while (!CHKBIT(MCASP->XGBLCTL, XHCLKRST)) {} SETBIT(MCASP->RGBLCTL, RHCLKRST); while (!CHKBIT(MCASP->RGBLCTL, RHCLKRST)) {} SETBIT(MCASP->XGBLCTL, XCLKRST); while (!CHKBIT(MCASP->XGBLCTL, XCLKRST)) {} SETBIT(MCASP->RGBLCTL, RCLKRST); while (!CHKBIT(MCASP->RGBLCTL, RCLKRST)) {} SETBIT(MCASP->XGBLCTL, XSRCLR); while (!CHKBIT(MCASP->XGBLCTL, XSRCLR)) {} SETBIT(MCASP->RGBLCTL, RSRCLR); while (!CHKBIT(MCASP->RGBLCTL, RSRCLR)) {} /* Write a 0, so that no underrun occurs after releasing the state machine */ MCASP->XBUF11 = 0; SETBIT(MCASP->XGBLCTL, XSMRST); while (!CHKBIT(MCASP->XGBLCTL, XSMRST)) {} SETBIT(MCASP->RGBLCTL, RSMRST); while (!CHKBIT(MCASP->RGBLCTL, RSMRST)) {} SETBIT(MCASP->XGBLCTL, XFRST); while (!CHKBIT(MCASP->XGBLCTL, XFRST)) {} SETBIT(MCASP->RGBLCTL, RFRST); while (!CHKBIT(MCASP->RGBLCTL, RFRST)) {} // wait for transmit ready and send a dummy byte. while(!CHKBIT(MCASP->SRCTL11, XRDY)) {} MCASP->XBUF11 = 0; // loop audio for (sec = 0; sec < 15; sec++) { for (msec = 0; msec < 1000; msec++) { for (sample = 0; sample < 48; sample++) { // wait for recv ready and send a sample to the left channel. while (!CHKBIT(MCASP->SRCTL11, XRDY)) {} MCASP->XBUF11 = dat; dat = MCASP->XBUF12; // wait for recv ready and send a sample to the right channel. while (!CHKBIT(MCASP->SRCTL11, XRDY)) {} MCASP->XBUF11 = dat; dat = MCASP->XBUF12; //printf("you received %d\n", dat); } } } return (rtn); }
void ALCHRecord::IsFood(bool value) { SETBIT(ENIT.value.flags, fIsFood, value); }
/* * _hash_getovflpage() * * Find an available overflow page and return it. The returned buffer * is pinned and write-locked, and has had _hash_pageinit() applied, * but it is caller's responsibility to fill the special space. * * The caller must hold a pin, but no lock, on the metapage buffer. * That buffer is left in the same state at exit. */ static Buffer _hash_getovflpage(Relation rel, Buffer metabuf) { HashMetaPage metap; Buffer mapbuf = 0; Buffer newbuf; BlockNumber blkno; uint32 orig_firstfree; uint32 splitnum; uint32 *freep = NULL; uint32 max_ovflpg; uint32 bit; uint32 first_page; uint32 last_bit; uint32 last_page; uint32 i, j; /* Get exclusive lock on the meta page */ _hash_chgbufaccess(rel, metabuf, HASH_NOLOCK, HASH_WRITE); _hash_checkpage(rel, metabuf, LH_META_PAGE); metap = HashPageGetMeta(BufferGetPage(metabuf)); /* start search at hashm_firstfree */ orig_firstfree = metap->hashm_firstfree; first_page = orig_firstfree >> BMPG_SHIFT(metap); bit = orig_firstfree & BMPG_MASK(metap); i = first_page; j = bit / BITS_PER_MAP; bit &= ~(BITS_PER_MAP - 1); /*CS3223*/ /* outer loop iterates once per bitmap page */ for (;;) { BlockNumber mapblkno; Page mappage; uint32 last_inpage; /* want to end search with the last existing overflow page */ splitnum = metap->hashm_ovflpoint; max_ovflpg = metap->hashm_spares[splitnum] - 1; last_page = max_ovflpg >> BMPG_SHIFT(metap); last_bit = max_ovflpg & BMPG_MASK(metap); if (i > last_page) break; Assert(i < metap->hashm_nmaps); mapblkno = metap->hashm_mapp[i]; if (i == last_page) last_inpage = last_bit; else last_inpage = BMPGSZ_BIT(metap) - 1; /* Release exclusive lock on metapage while reading bitmap page */ _hash_chgbufaccess(rel, metabuf, HASH_READ, HASH_NOLOCK); mapbuf = _hash_getbuf(rel, mapblkno, HASH_WRITE, LH_BITMAP_PAGE); mappage = BufferGetPage(mapbuf); freep = HashPageGetBitmap(mappage); for (; bit <= last_inpage; j++, bit += BITS_PER_MAP) { if (freep[j] != ALL_SET) goto found; } /* No free space here, try to advance to next map page */ _hash_relbuf(rel, mapbuf); i++; j = 0; /* scan from start of next map page */ bit = 0; /* Reacquire exclusive lock on the meta page */ _hash_chgbufaccess(rel, metabuf, HASH_NOLOCK, HASH_WRITE); } /* * No free pages --- have to extend the relation to add an overflow page. * First, check to see if we have to add a new bitmap page too. */ if (last_bit == (uint32) (BMPGSZ_BIT(metap) - 1)) { /* * We create the new bitmap page with all pages marked "in use". * Actually two pages in the new bitmap's range will exist * immediately: the bitmap page itself, and the following page which * is the one we return to the caller. Both of these are correctly * marked "in use". Subsequent pages do not exist yet, but it is * convenient to pre-mark them as "in use" too. */ bit = metap->hashm_spares[splitnum]; _hash_initbitmap(rel, metap, bitno_to_blkno(metap, bit), MAIN_FORKNUM); metap->hashm_spares[splitnum]++; } else { /* * Nothing to do here; since the page will be past the last used page, * we know its bitmap bit was preinitialized to "in use". */ } /* Calculate address of the new overflow page */ bit = metap->hashm_spares[splitnum]; blkno = bitno_to_blkno(metap, bit); /* * Fetch the page with _hash_getnewbuf to ensure smgr's idea of the * relation length stays in sync with oursit. XXX It's annoying to do this * with metapage write lock held; would be better to use a lock that * doesn't block incoming searches. */ newbuf = _hash_getnewbuf(rel, blkno, MAIN_FORKNUM); metap->hashm_spares[splitnum]++; /* * Adjust hashm_firstfree to avoid redundant searches. But don't risk * changing it if someone moved it while we were searching bitmap pages. */ if (metap->hashm_firstfree == orig_firstfree) metap->hashm_firstfree = bit + 1; /* Write updated metapage and release lock, but not pin */ _hash_chgbufaccess(rel, metabuf, HASH_WRITE, HASH_NOLOCK); return newbuf; found: /* convert bit to bit number within page */ bit += _hash_firstfreebit(freep[j]); /* mark page "in use" in the bitmap */ SETBIT(freep, bit); _hash_wrtbuf(rel, mapbuf); /* Reacquire exclusive lock on the meta page */ _hash_chgbufaccess(rel, metabuf, HASH_NOLOCK, HASH_WRITE); /* convert bit to absolute bit number */ bit += (i << BMPG_SHIFT(metap)); /* Calculate address of the recycled overflow page */ blkno = bitno_to_blkno(metap, bit); /* * Adjust hashm_firstfree to avoid redundant searches. But don't risk * changing it if someone moved it while we were searching bitmap pages. */ if (metap->hashm_firstfree == orig_firstfree) { metap->hashm_firstfree = bit + 1; /* Write updated metapage and release lock, but not pin */ _hash_chgbufaccess(rel, metabuf, HASH_WRITE, HASH_NOLOCK); } else { /* We didn't change the metapage, so no need to write */ _hash_chgbufaccess(rel, metabuf, HASH_READ, HASH_NOLOCK); } /* Fetch, init, and return the recycled page */ return _hash_getinitbuf(rel, blkno); }
void ALCHRecord::IsNoAutoCalc(bool value) { SETBIT(ENIT.value.flags, fIsNoAutoCalc, value); }
/* ** This routine runs an extensive test of the Bitvec code. ** ** The input is an array of integers that acts as a program ** to test the Bitvec. The integers are opcodes followed ** by 0, 1, or 3 operands, depending on the opcode. Another ** opcode follows immediately after the last operand. ** ** There are 6 opcodes numbered from 0 through 5. 0 is the ** "halt" opcode and causes the test to end. ** ** 0 Halt and return the number of errors ** 1 N S X Set N bits beginning with S and incrementing by X ** 2 N S X Clear N bits beginning with S and incrementing by X ** 3 N Set N randomly chosen bits ** 4 N Clear N randomly chosen bits ** 5 N S X Set N bits from S increment X in array only, not in bitvec ** ** The opcodes 1 through 4 perform set and clear operations are performed ** on both a Bitvec object and on a linear array of bits obtained from malloc. ** Opcode 5 works on the linear array only, not on the Bitvec. ** Opcode 5 is used to deliberately induce a fault in order to ** confirm that error detection works. ** ** At the conclusion of the test the linear array is compared ** against the Bitvec object. If there are any differences, ** an error is returned. If they are the same, zero is returned. ** ** If a memory allocation error occurs, return -1. */ int sqlite3BitvecBuiltinTest(int sz, int *aOp){ Bitvec *pBitvec = 0; unsigned char *pV = 0; int rc = -1; int i, nx, pc, op; void *pTmpSpace; /* Allocate the Bitvec to be tested and a linear array of ** bits to act as the reference */ pBitvec = sqlite3BitvecCreate( sz ); pV = sqlite3MallocZero( (sz+7)/8 + 1 ); pTmpSpace = sqlite3_malloc64(BITVEC_SZ); if( pBitvec==0 || pV==0 || pTmpSpace==0 ) goto bitvec_end; /* NULL pBitvec tests */ sqlite3BitvecSet(0, 1); sqlite3BitvecClear(0, 1, pTmpSpace); /* Run the program */ pc = 0; while( (op = aOp[pc])!=0 ){ switch( op ){ case 1: case 2: case 5: { nx = 4; i = aOp[pc+2] - 1; aOp[pc+2] += aOp[pc+3]; break; } case 3: case 4: default: { nx = 2; sqlite3_randomness(sizeof(i), &i); break; } } if( (--aOp[pc+1]) > 0 ) nx = 0; pc += nx; i = (i & 0x7fffffff)%sz; if( (op & 1)!=0 ){ SETBIT(pV, (i+1)); if( op!=5 ){ if( sqlite3BitvecSet(pBitvec, i+1) ) goto bitvec_end; } }else{ CLEARBIT(pV, (i+1)); sqlite3BitvecClear(pBitvec, i+1, pTmpSpace); } } /* Test to make sure the linear array exactly matches the ** Bitvec object. Start with the assumption that they do ** match (rc==0). Change rc to non-zero if a discrepancy ** is found. */ rc = sqlite3BitvecTest(0,0) + sqlite3BitvecTest(pBitvec, sz+1) + sqlite3BitvecTest(pBitvec, 0) + (sqlite3BitvecSize(pBitvec) - sz); for(i=1; i<=sz; i++){ if( (TESTBIT(pV,i))!=sqlite3BitvecTest(pBitvec,i) ){ rc = i; break; } } /* Free allocated structure */ bitvec_end: sqlite3_free(pTmpSpace); sqlite3_free(pV); sqlite3BitvecDestroy(pBitvec); return rc; }
int main ( int argc, char ** argv ) { int i; int nedges; int nmasks; int fpsave; bitmap_t * edge_mask; bitmap_t * all_fsets_mask; bitmap_t * no_fsets_mask; int count; char tbuf [20]; char title [128]; struct cinfo cinfo; fpsave = set_floating_point_double_precision (); setbuf (stdout, NULL); decode_params (argc, argv); init_tables (); read_phase_1_data (&cinfo); edge_mask = cinfo.initial_edge_mask; convert_cpu_time (cinfo.p1time, tbuf); printf (" %% Phase 1: %s seconds\n", tbuf); /* Prepare for plotting all terminals. */ define_Plot_Terminals (cinfo.pts, &cinfo.scale); nedges = cinfo.num_edges; nmasks = cinfo.num_edge_masks; all_fsets_mask = NEWA (nmasks, bitmap_t); no_fsets_mask = NEWA (nmasks, bitmap_t); for (i = 0; i < nmasks; i++) { all_fsets_mask [i] = 0; no_fsets_mask [i] = 0; } for (i = 0; i < nedges; i++) { SETBIT (all_fsets_mask, i); } if (Print_Points) { if ((cinfo.description NE NULL) AND (cinfo.description [0] NE '\0')) { strcpy (title, cinfo.description); } else { sprintf (title, "%lu points", (int32u) cinfo.num_verts); } overlay_plot_subset (title, no_fsets_mask, &cinfo, BIG_PLOT); } if (Print_Full_Sets) { plot_full_sets (all_fsets_mask, &cinfo, SMALL_PLOT); } if (Print_Grouped_Full_Sets) { plot_full_sets_grouped (all_fsets_mask, &cinfo, SMALL_PLOT); } if (Print_Overlaid_Full_Sets) { sprintf (title, "All FSTs: %lu points, %s seconds", (int32u) cinfo.num_verts, tbuf); overlay_plot_subset (title, edge_mask, &cinfo, BIG_PLOT); } restore_floating_point_precision (fpsave); exit (0); }
void WRLDRecord::IsNoFastTravel(bool value) { SETBIT(DATA.value, fIsNoFastTravel, value); }
struct constraint * add_cutset_to_list ( bitmap_t * cutset, /* IN - new cutset to add */ struct constraint * cutlist, /* IN - list to add to */ double * x, /* IN - current LP solution */ bitmap_t * vert_mask, /* IN - set of valid terminals */ bitmap_t * edge_mask, /* IN - set of valid hyperedges */ struct cinfo * cip /* IN - compatibility info */ ) { int i; int j; int nedges; int nmasks; int num_in_cut; int count; int * vp1; int * vp2; struct constraint * p; struct constraint ** hookp; bitmap_t * cut_edges; double z; nedges = cip -> num_edges; nmasks = cip -> num_edge_masks; cut_edges = NEWA (nmasks, bitmap_t); memset (cut_edges, 0, nmasks * sizeof (*cut_edges)); count = 0; z = 0.0; for (i = 0; i < cip -> num_edges; i++) { if (NOT BITON (edge_mask, i)) continue; num_in_cut = 0; vp1 = cip -> edge [i]; vp2 = cip -> edge [i + 1]; while (vp1 < vp2) { j = *vp1++; if (BITON (cutset, j)) { ++num_in_cut; } } if (num_in_cut <= 0) { /* this hyperedge resides entirely */ /* outside of the cut... doesn't span! */ continue; } if (num_in_cut >= cip -> edge_size [i]) { /* this hyperedge resides entirely */ /* within the cut... doesn't span! */ continue; } SETBIT (cut_edges, i); ++count; z += x [i]; } /* Check for an all-zero cutset. These occasionally */ /* happen because of numeric issues... */ if (count <= 0) { /* Empty cutset! OOOPS! */ #if 1 tracef (" %% WARNING! empty cutset!\n"); #endif free ((char *) cut_edges); return (cutlist); } if (z >= 1.0 - FUZZ) { #if 1 tracef (" %% WARNING! bogus cutset!\n"); #endif free ((char *) cut_edges); return (cutlist); } /* If this new cutset is a superset of an existing one, */ /* then there is nothing to add, and nothing to delete. */ for (p = cutlist; p NE NULL; p = p -> next) { if (is_subset (p -> mask, cut_edges, nmasks)) { free (cut_edges); return (cutlist); } } /* Delete all current cutsets which have this new one */ /* as a subset. */ hookp = &cutlist; while ((p = *hookp) NE NULL) { if (p -> type NE CT_CUTSET) { hookp = &(p -> next); } else if (is_subset (cut_edges, p -> mask, nmasks)) { *hookp = p -> next; free ((char *) (p -> mask)); free ((char *) p); } else { hookp = &(p -> next); } } p = NEW (struct constraint); p -> next = NULL; p -> iteration = 0; p -> type = CT_CUTSET; p -> mask = cut_edges; *hookp = p; return (cutlist); }
void WRLDRecord::IsUseLandData(bool value) { SETBIT(PNAM.value, fIsUseLandData, value); }
int splitQuotedStr ( char *str, char *delims, uint flgs, int maxWrdCnt, char *(**words) ) { int wrdcnt = 0; uint flags = 0; char *Buffer = (char *)malloc(sizeof(char) * (strlen(str) + 1)); char *bufPos = Buffer; char *ptr; char *p; //take the given flags... for now it's only FL_DLMFLD if (GETBIT(flgs, FL_DLMFLD)) SETBIT(flags, FL_DLMFLD); if (!(*words)) *words=(char **)malloc(sizeof(char*)); for (ptr = str; *ptr && (GETBIT(flags, FL_MAXWRD) == 0); ptr++) { if ((*ptr == '\\') && (GETBIT(flags, FL_ESC)==0)) { SETBIT(flags, FL_ESC); #ifdef DEBUG fprintf(stderr, "Continue due to escape-char\n"); #endif continue; } if (*ptr == '\"') { //Wenn 1. das vorhergehende Zeichen kein \ ist // und 2. wir nicht inmitten eines '-Wortes sind (singlequote) if ((GETBIT(flags, FL_ESC) == 0) && (GETBIT(flags, FL_SQOT) == 0) ) { //...dann beginnt oder endet hier nun ein "-Wort (dblquote) SWPBIT(flags, FL_DQOT); SETBIT(flags, FL_QOTCHGD); //indikator für quote-grenze setzen } } if (*ptr == '\'') { //Wenn 1. das vorhergehende Zeichen kein \ ist // und 2. wir nicht inmitten eines "-Wortes sind (dblquote) if ((GETBIT(flags, FL_ESC) == 0) && (GETBIT(flags, FL_DQOT) == 0) ) { //...dann beginnt oder endet hier nun ein '-Wort (singlequote) SWPBIT(flags, FL_SQOT); SETBIT(flags, FL_QOTCHGD); //indikator für wort-grenze setzen } } //so, nun sollte alles geklaert sein. wenn wir nicht inmitten eines //wortes sind, dann schauen wir mal, ob wir es mit einem //delimiter zu tun haben dem auch kein escape-Zeichen vorangeht: if ( (GETBIT(flags, FL_SQOT) == 0) && (GETBIT(flags, FL_DQOT) == 0) && (GETBIT(flags, FL_ESC) == 0) ) { for (p = delims; *p; p++) if (*ptr == *p) { SETBIT(flags, FL_DLM); } } //So, nun sind wir fast fertig: Wenn wir nicht auf einem delimiter stehen, //dann kopieren wir das aktuelle Zeichen in den puffer if (GETBIT(flags, FL_DLM) == 0) { if (GETBIT(flags, FL_QOTCHGD) == 0) { *bufPos++ = *ptr; *bufPos = '\0'; } } else { //Irgendwie müssen wir hier nun den Delimiter bearbeiten. if (GETBIT(flags, FL_DLMFLD) == 1) { //wenn delimiterfolding (FL_DLMFLD) aktiv ist, dann //dürfen wir keine leeren Wörter ausgeben: if (strlen(Buffer)) SETBIT(flags, FL_WRDFIN); } else { //ansonsten ist uns das egal was in dem Wort steht. SETBIT(flags, FL_WRDFIN); } //ggf beginnen wir nun ein neues Wort und resetten den Buffer fuer //das naechste Wort: if (GETBIT(flags, FL_WRDFIN)) { *words = (char **)realloc(*(words), (wrdcnt + 1) * sizeof(char *)); ((*words)[wrdcnt++]) = strdup(Buffer); bufPos = Buffer; *bufPos = '\0'; //wenn maxWordCount definiert (>0) und erreicht ist, dann //setzen wir mal das Flag zum Iterationsabbruch if ((maxWrdCnt > 0) && (wrdcnt == maxWrdCnt)) { SETBIT(flags, FL_MAXWRD); #ifdef DEBUG fprintf(stderr, "Break due to maxWrdCnt == %d\n", maxWrdCnt); #endif } } } #ifdef DEBUG fprintf(stderr, "%3d: %c: (0x%x = %d%d%d%d%d%d%d%d) %s\n", wrdcnt, *ptr, (int)flags, GETBIT(flags, FL_MAXWRD), GETBIT(flags, FL_WRDFIN), GETBIT(flags, FL_DLMFLD), GETBIT(flags, FL_DLM), GETBIT(flags, FL_QOTCHGD), GETBIT(flags, FL_SQOT), GETBIT(flags, FL_DQOT), GETBIT(flags, FL_ESC), Buffer ); splitQuotedStr_DebugFlags(flags); #endif //Iterations-Abschluss: //nun alle noetigen Flags für den nächsten Durchlauf neu initialisieren CLRBIT(flags, FL_WRDFIN); CLRBIT(flags, FL_DLM); CLRBIT(flags, FL_ESC); CLRBIT(flags, FL_QOTCHGD); //indikator für wort-grenze setzen } //for ptr... //Wenn bereits innerhalb der Iteration die max. Anzahl von Wörtern erreicht //wurde, dann brauchen wir uns um ggf gelesenen Rest nicht mehr kuemmern: if (GETBIT(flags, FL_MAXWRD) == 0) { //...ansonsten schauen wir uns das doch gleich mal etwas genauer an... //es sei: das letzte Wort speichern, wenn was im Buffer ist, oder, //wenn Delimiterfolding inaktiv ist. if ( strlen(Buffer) || ((GETBIT(flags, FL_DLMFLD) == 0) && GETBIT(flags, FL_WRDFIN == 1)) ) { #ifdef DEBUG fprintf(stderr, "at the end: create last word from buffer.\n"); #endif *(words) = (char **)realloc(*(words), (wrdcnt + 1) * sizeof(char*)); ((*words)[wrdcnt++]) = strdup(Buffer); } } #ifdef DEBUG fprintf(stderr, "final flag-status: "); splitQuotedStr_DebugFlags(flags); #endif //so, zum Schluss noch etwas housekeeping... free(Buffer); if (GETBIT(flags, FL_DQOT) == 0 && GETBIT(flags, FL_SQOT) == 0) { return (wrdcnt); } else { int i = 0; for (i = 0; i < wrdcnt; i++) free((*words)[i]); return (-1); } }
void WRLDRecord::IsUseImageSpaceData(bool value) { SETBIT(PNAM.value, fIsUseImageSpaceData, value); }
static cmph_uint8 bmz_traverse_critical_nodes(bmz_config_data_t *bmz, cmph_uint32 v, cmph_uint32 * biggest_g_value, cmph_uint32 * biggest_edge_value, cmph_uint8 * used_edges, cmph_uint8 * visited) { cmph_uint32 next_g; cmph_uint32 u; /* Auxiliary vertex */ cmph_uint32 lav; /* lookahead vertex */ cmph_uint8 collision; vqueue_t * q = vqueue_new((cmph_uint32)(graph_ncritical_nodes(bmz->graph)) + 1); graph_iterator_t it, it1; DEBUGP("Labelling critical vertices\n"); bmz->g[v] = (cmph_uint32)ceil ((double)(*biggest_edge_value)/2) - 1; SETBIT(visited, v); next_g = (cmph_uint32)floor((double)(*biggest_edge_value/2)); /* next_g is incremented in the do..while statement*/ vqueue_insert(q, v); while(!vqueue_is_empty(q)) { v = vqueue_remove(q); it = graph_neighbors_it(bmz->graph, v); while ((u = graph_next_neighbor(bmz->graph, &it)) != GRAPH_NO_NEIGHBOR) { if (graph_node_is_critical(bmz->graph, u) && (!GETBIT(visited,u))) { collision = 1; while(collision) // lookahead to resolve collisions { next_g = *biggest_g_value + 1; it1 = graph_neighbors_it(bmz->graph, u); collision = 0; while((lav = graph_next_neighbor(bmz->graph, &it1)) != GRAPH_NO_NEIGHBOR) { if (graph_node_is_critical(bmz->graph, lav) && GETBIT(visited,lav)) { if(next_g + bmz->g[lav] >= bmz->m) { vqueue_destroy(q); return 1; // restart mapping step. } if (GETBIT(used_edges, (next_g + bmz->g[lav]))) { collision = 1; break; } } } if (next_g > *biggest_g_value) *biggest_g_value = next_g; } // Marking used edges... it1 = graph_neighbors_it(bmz->graph, u); while((lav = graph_next_neighbor(bmz->graph, &it1)) != GRAPH_NO_NEIGHBOR) { if (graph_node_is_critical(bmz->graph, lav) && GETBIT(visited, lav)) { SETBIT(used_edges,(next_g + bmz->g[lav])); if(next_g + bmz->g[lav] > *biggest_edge_value) *biggest_edge_value = next_g + bmz->g[lav]; } } bmz->g[u] = next_g; // Labelling vertex u. SETBIT(visited,u); vqueue_insert(q, u); } } } vqueue_destroy(q); return 0; }
int ParseEPD (char *p) /************************************************************************** * * Parses an EPD input line. A few global variables are updated e.g. * current board, side to move, en passant, castling status, etc. * **************************************************************************/ { int r, c, sq; char *str_p; r = 56; c = 0; memset (&board, 0, sizeof (board)); while (p && *p != ' ') { sq = r + c; switch (*p) { case 'P' : SETBIT (board.b[white][pawn], sq); SETBIT (board.blockerr90, r90[sq]); SETBIT (board.blockerr45, r45[sq]); SETBIT (board.blockerr315, r315[sq]); board.material[white] += ValueP; break; case 'N' : SETBIT (board.b[white][knight], sq); SETBIT (board.blockerr90, r90[sq]); SETBIT (board.blockerr45, r45[sq]); SETBIT (board.blockerr315, r315[sq]); board.material[white] += ValueN; break; case 'B' : SETBIT (board.b[white][bishop], sq); SETBIT (board.blockerr90, r90[sq]); SETBIT (board.blockerr45, r45[sq]); SETBIT (board.blockerr315, r315[sq]); board.material[white] += ValueB; break; case 'R' : SETBIT (board.b[white][rook], sq); SETBIT (board.blockerr90, r90[sq]); SETBIT (board.blockerr45, r45[sq]); SETBIT (board.blockerr315, r315[sq]); board.material[white] += ValueR; break; case 'Q' : SETBIT (board.b[white][queen], sq); SETBIT (board.blockerr90, r90[sq]); SETBIT (board.blockerr45, r45[sq]); SETBIT (board.blockerr315, r315[sq]); board.material[white] += ValueQ; break; case 'K' : SETBIT (board.b[white][king], sq); SETBIT (board.blockerr90, r90[sq]); SETBIT (board.blockerr45, r45[sq]); SETBIT (board.blockerr315, r315[sq]); break; case 'p' : SETBIT (board.b[black][pawn], sq); SETBIT (board.blockerr90, r90[sq]); SETBIT (board.blockerr45, r45[sq]); SETBIT (board.blockerr315, r315[sq]); board.material[black] += ValueP; break; case 'n' : SETBIT (board.b[black][knight], sq); SETBIT (board.blockerr90, r90[sq]); SETBIT (board.blockerr45, r45[sq]); SETBIT (board.blockerr315, r315[sq]); board.material[black] += ValueN; break; case 'b' : SETBIT (board.b[black][bishop], sq); SETBIT (board.blockerr90, r90[sq]); SETBIT (board.blockerr45, r45[sq]); SETBIT (board.blockerr315, r315[sq]); board.material[black] += ValueB; break; case 'r' : SETBIT (board.b[black][rook], sq); SETBIT (board.blockerr90, r90[sq]); SETBIT (board.blockerr45, r45[sq]); SETBIT (board.blockerr315, r315[sq]); board.material[black] += ValueR; break; case 'q' : SETBIT (board.b[black][queen], sq); SETBIT (board.blockerr90, r90[sq]); SETBIT (board.blockerr45, r45[sq]); SETBIT (board.blockerr315, r315[sq]); board.material[black] += ValueQ; break; case 'k' : SETBIT (board.b[black][king], sq); SETBIT (board.blockerr90, r90[sq]); SETBIT (board.blockerr45, r45[sq]); SETBIT (board.blockerr315, r315[sq]); break; case '/' : r -= 8; c = -1; break; default : break; } if (isdigit (*p)) c += (*p - '0'); else c++; /* * Special case, a trailing "/" is accepted on the * end of the board settings. */ if (r == -8 && p[1] == ' ') r = 0; if (r < 0 || c > 8) return EPD_ERROR; if (c == 8 && p[1] != '/' && p[1] != ' ') return EPD_ERROR; p++; } board.pmaterial[white] = board.material[white] - nbits(board.b[white][pawn]) * ValueP; board.pmaterial[black] = board.material[black] - nbits(board.b[black][pawn]) * ValueP; board.king[white] = leadz (board.b[white][king]); board.king[black] = leadz (board.b[black][king]); UpdateFriends (); UpdateCBoard (); UpdateMvboard (); /* Get side to move */ if (!++p) return EPD_ERROR; if (*p == 'w') board.side = white; else if (*p == 'b') board.side = black; else return EPD_ERROR; /* Isn't this one cute? */ if (!++p || *p != ' ' || !++p) return EPD_ERROR; /* Castling status */ while (p && *p != ' ') { if (*p == 'K') board.flag |= WKINGCASTLE; else if (*p == 'Q') board.flag |= WQUEENCASTLE; else if (*p == 'k') board.flag |= BKINGCASTLE; else if (*p == 'q') board.flag |= BQUEENCASTLE; else if (*p == '-') { p++; break; } else return EPD_ERROR; p++; } if (!p || *p != ' ' || !++p) return EPD_ERROR; /* * En passant square, can only be '-' or [a-h][36] * In fact, one could add more sanity checks here. */ if (*p != '-') { if (!p[1] || *p < 'a' || *p > 'h' || !(p[1] == '3' || p[1] == '6')) return EPD_ERROR; board.ep = (*p - 'a') + (p[1] - '1')*8; p++; } else { board.ep = -1; } solution[0] = '\0'; id[0] = '\0'; if (!++p) return EPD_SUCCESS; /* The opcodes are optional, so we should not generate errors here */ /* Read in best move; "bm" operator */ str_p = strstr(p, "bm"); if (str_p) sscanf (str_p, "bm %63[^;];", solution); /* Read in the description; "id" operator */ str_p = strstr(p, "id"); if (str_p) sscanf (p, "id %31[^;];", id); phase = PHASE; return EPD_SUCCESS; }
static cmph_uint8 bmz_traverse_critical_nodes_heuristic(bmz_config_data_t *bmz, cmph_uint32 v, cmph_uint32 * biggest_g_value, cmph_uint32 * biggest_edge_value, cmph_uint8 * used_edges, cmph_uint8 * visited) { cmph_uint32 next_g; cmph_uint32 u; /* Auxiliary vertex */ cmph_uint32 lav; /* lookahead vertex */ cmph_uint8 collision; cmph_uint32 * unused_g_values = NULL; cmph_uint32 unused_g_values_capacity = 0; cmph_uint32 nunused_g_values = 0; vqueue_t * q = vqueue_new((cmph_uint32)(0.5*graph_ncritical_nodes(bmz->graph))+1); graph_iterator_t it, it1; DEBUGP("Labelling critical vertices\n"); bmz->g[v] = (cmph_uint32)ceil ((double)(*biggest_edge_value)/2) - 1; SETBIT(visited, v); next_g = (cmph_uint32)floor((double)(*biggest_edge_value/2)); /* next_g is incremented in the do..while statement*/ vqueue_insert(q, v); while(!vqueue_is_empty(q)) { v = vqueue_remove(q); it = graph_neighbors_it(bmz->graph, v); while ((u = graph_next_neighbor(bmz->graph, &it)) != GRAPH_NO_NEIGHBOR) { if (graph_node_is_critical(bmz->graph, u) && (!GETBIT(visited,u))) { cmph_uint32 next_g_index = 0; collision = 1; while(collision) // lookahead to resolve collisions { if (next_g_index < nunused_g_values) { next_g = unused_g_values[next_g_index++]; } else { next_g = *biggest_g_value + 1; next_g_index = UINT_MAX; } it1 = graph_neighbors_it(bmz->graph, u); collision = 0; while((lav = graph_next_neighbor(bmz->graph, &it1)) != GRAPH_NO_NEIGHBOR) { if (graph_node_is_critical(bmz->graph, lav) && GETBIT(visited,lav)) { if(next_g + bmz->g[lav] >= bmz->m) { vqueue_destroy(q); free(unused_g_values); return 1; // restart mapping step. } if (GETBIT(used_edges, (next_g + bmz->g[lav]))) { collision = 1; break; } } } if(collision && (next_g > *biggest_g_value)) // saving the current g value stored in next_g. { if(nunused_g_values == unused_g_values_capacity) { unused_g_values = (cmph_uint32 *)realloc(unused_g_values, (unused_g_values_capacity + BUFSIZ)*sizeof(cmph_uint32)); unused_g_values_capacity += BUFSIZ; } unused_g_values[nunused_g_values++] = next_g; } if (next_g > *biggest_g_value) *biggest_g_value = next_g; } next_g_index--; if (next_g_index < nunused_g_values) unused_g_values[next_g_index] = unused_g_values[--nunused_g_values]; // Marking used edges... it1 = graph_neighbors_it(bmz->graph, u); while((lav = graph_next_neighbor(bmz->graph, &it1)) != GRAPH_NO_NEIGHBOR) { if (graph_node_is_critical(bmz->graph, lav) && GETBIT(visited, lav)) { SETBIT(used_edges,(next_g + bmz->g[lav])); if(next_g + bmz->g[lav] > *biggest_edge_value) *biggest_edge_value = next_g + bmz->g[lav]; } } bmz->g[u] = next_g; // Labelling vertex u. SETBIT(visited, u); vqueue_insert(q, u); } } } vqueue_destroy(q); free(unused_g_values); return 0; }
void FURNRecord::IsAnim17(bool value) { SETBIT(MNAM.value, fIsAnim17, value); }
void CELLRecord::IsLightFogPowerInherited(bool value) { SETBIT(LNAM.value, fIsFogPowerInherited, value); }