int ParseChannel(channel_t* chan, channel_easy* chanE) { memcpy(chanE->name, chan->name, 32); chanE->name[15] = '\0'; chanE->bIsDigital = getType(chan); /* chanE->TOT = getTOT(chan); chanE->EmergencyIndex = getEmergencyIndex(chan); chanE->GroupListIndex = getGroupListIndex(chan); chanE->ScanListIndex = getScanListIndex(chan); chanE->ContactIndex = getContactIndex(chan); chanE->AutoScan = getAutoScan(chan); */ readFrequency(chan, &chanE->rxFreq, 1); readFrequency(chan, &chanE->txFreq, 0); if (chanE->bIsDigital) { chanE->CC = 0; chanE->Slot = 0; chanE->ContactIndex = 0; readTone(chan, &chanE->DecTone, FALSE); readTone(chan, &chanE->EncTone, TRUE); } else { chanE->CC = getCC(chan); chanE->Slot = getSlot(chan); sprintf(chanE->DecTone.text, "N/A"); sprintf(chanE->EncTone.text, "N/A"); } return 0; }
float ramCommunicationManager::getCC(const string &name, int ccNum) const { int index = 0; for (int i = 0; i < Instruments.size(); i++) { if (name == Instruments[i]->getName()) index = i; } return getCC(index,ccNum); }
// Function: dumpProcessorRegisters // Description: This Function outputs the contents of the YESS // processor registers to standard out. // Params: none // Returns: none // Modifies: none void dumpProcessorRegisters() { fregister F = getFregister(); dregister D = getDregister(); eregister E = getEregister(); mregister M = getMregister(); wregister W = getWregister(); printf("CC - ZF: %01x SF: %01x OF: %01x\n", getCC(ZF), getCC(SF), getCC(OF)); printf("F - predPC: %08x\n", F.predPC); printf("D - stat: %01x icode: %01x ifun: %01x rA: %01x rB: %01x valC: %08x valP: %08x\n", D.stat, D.icode, D.ifun, D.rA, D.rB, D.valC, D.valP); printf("E - stat: %01x icode: %01x ifun: %01x valC: %08x valA: %08x valB: %08x\n", E.stat, E.icode, E.ifun, E.valC, E.valA, E.valB); printf(" dstE: %01x dstM: %01x srcA: %01x srcB: %01x\n", E.dstE, E.dstM, E.srcA, E.srcB); printf("M - stat: %01x icode: %01x Cnd: %01x valE: %08x valA: %08x dstE: %01x dstM: %01x\n", M.stat, M.icode, M.Cnd, M.valE, M.valA, M.dstE, M.dstM); printf("W - stat: %01x icode: %01x valE: %08x valM: %08x dstE: %01x dstM: %01x\n\n", W.stat, W.icode, W.valE, W.valM, W.dstE, W.dstM); }
unsigned int getCnd() { if (E.icode == ICMOVXX || E.icode == IJXX) { bool zero = getCC(ZF); bool sign = getCC(SF); bool overflow = getCC(OF); switch (E.ifun) { case F_LE: return ((zero || sign) && !overflow) || (overflow && !sign); case F_L: return (sign && !(zero || overflow)) || (overflow && !sign); case F_E: return zero; case F_NE: return !zero; case F_GE: return (!overflow && (zero || !sign)) || (overflow && !zero && sign); case F_G: return (!overflow && !sign && !zero) || (overflow && sign); case F_NO_CND: return 1; } } return 0; }
UBool Normalizer2DataBuilder::combinesWithCCBetween(const Norm &norm, uint8_t lowCC, uint8_t highCC) const { if((highCC-lowCC)>=2) { int32_t length; const CompositionPair *pairs=norm.getCompositionPairs(length); for(int32_t i=0; i<length; ++i) { uint8_t trailCC=getCC(pairs[i].trail); if(lowCC<trailCC && trailCC<highCC) { return TRUE; } } } return FALSE; }
int main(int argc, char *argv[]) { if (argc != 4) { printf("Usage: %s nx ny steps.\n", argv[0]); return 1; } int i; le_point2 n = {atoi(argv[1]), atoi(argv[2])}; int steps = atoi(argv[3]); le_task task; le_material mat; le_vec2 h = {1.0, 1.0}; real dt = 0.3; le_vec2 center = {n.x / 2, n.y / 2}; char name[1000]; double t; unsigned long cc; /* * Init material. */ le_init_material(2.0, 1.0, 1.5, &mat); /* * Init task. */ le_init_task(&task, dt, h, mat, n, ST_SOA); /* * Initial condition. */ le_set_ball(&task, center, 10.0, 1.0); cc = getCC(); t = timer(); for (i = 0; i < steps; i++) { if (save_every_step) { sprintf(name, "out-%06d.vtk", i); le_save_task(&task, name); } le_step_sse(&task); } t = timer() - t; cc = getCC() - cc; /*printf("Total time, s:\t\t%f\n", t); printf("Time per step, s:\t%f\n", t / steps);*/ printf("%d %d %d %f %ld\n", n.x, n.y, steps, t, cc); /* * Save last step. */ le_save_task(&task, "result.vtk"); /* * Free memory. */ le_free_task(&task); return 0; }
// Function: computeCND() // Description: just returns 0 // Params: none // Returns: zero // Modifies: none int computeCND() { int e_CND = 0; int sf = getCC(SF); int zf = getCC(ZF); int of = getCC(OF); if(E.icode != RRMOVL && E.icode != JXX) { return 0; } if(E.ifun == 0) { e_CND = 1; } else if(E.ifun == 1) { if((sf ^ of) || zf) e_CND = 1; } else if(E.ifun == 2) { if(sf ^ of) { e_CND = 1; } } else if(E.ifun == 3) { if(zf) { e_CND = 1; } } else if(E.ifun == 4) { if(!zf) { e_CND = 1; } } else if(E.ifun == 5) { //if(!(sf^of) & !zf) if(!(sf^of) ) { e_CND = 1; } } else if(E.ifun == 6) { if(!(sf^of) && !zf) { e_CND = 1; } } else { e_CND = 0; } return e_CND; }
UBool Normalizer2DataBuilder::decompose(UChar32 start, UChar32 end, uint32_t value) { if(norms[value].hasMapping()) { Norm &norm=norms[value]; const UnicodeString &m=*norm.mapping; UnicodeString *decomposed=NULL; const UChar *s=m.getBuffer(); int32_t length=m.length(); int32_t prev, i=0; UChar32 c; while(i<length) { prev=i; U16_NEXT(s, i, length, c); if(start<=c && c<=end) { fprintf(stderr, "gennorm2 error: U+%04lX maps to itself directly or indirectly\n", (long)c); exit(U_INVALID_FORMAT_ERROR); } const Norm &cNorm=getNormRef(c); if(cNorm.hasMapping()) { if(norm.mappingType==Norm::ROUND_TRIP) { if(prev==0) { if(cNorm.mappingType!=Norm::ROUND_TRIP) { fprintf(stderr, "gennorm2 error: " "U+%04lX's round-trip mapping's starter " "U+%04lX one-way-decomposes, " "not possible in Unicode normalization\n", (long)start, (long)c); exit(U_INVALID_FORMAT_ERROR); } uint8_t myTrailCC=getCC(m.char32At(i)); UChar32 cTrailChar=cNorm.mapping->char32At(cNorm.mapping->length()-1); uint8_t cTrailCC=getCC(cTrailChar); if(cTrailCC>myTrailCC) { fprintf(stderr, "gennorm2 error: " "U+%04lX's round-trip mapping's starter " "U+%04lX decomposes and the " "inner/earlier tccc=%hu > outer/following tccc=%hu, " "not possible in Unicode normalization\n", (long)start, (long)c, (short)cTrailCC, (short)myTrailCC); exit(U_INVALID_FORMAT_ERROR); } } else { fprintf(stderr, "gennorm2 error: " "U+%04lX's round-trip mapping's non-starter " "U+%04lX decomposes, " "not possible in Unicode normalization\n", (long)start, (long)c); exit(U_INVALID_FORMAT_ERROR); } } if(decomposed==NULL) { decomposed=new UnicodeString(m, 0, prev); } decomposed->append(*cNorm.mapping); } else if(Hangul::isHangul(c)) { UChar buffer[3]; int32_t hangulLength=Hangul::decompose(c, buffer); if(norm.mappingType==Norm::ROUND_TRIP && prev!=0) { fprintf(stderr, "gennorm2 error: " "U+%04lX's round-trip mapping's non-starter " "U+%04lX decomposes, " "not possible in Unicode normalization\n", (long)start, (long)c); exit(U_INVALID_FORMAT_ERROR); } if(decomposed==NULL) { decomposed=new UnicodeString(m, 0, prev); } decomposed->append(buffer, hangulLength); } else if(decomposed!=NULL) { decomposed->append(m, prev, i-prev); } } if(decomposed!=NULL) { if(norm.rawMapping==NULL) { // Remember the original mapping when decomposing recursively. norm.rawMapping=norm.mapping; } else { delete norm.mapping; } norm.mapping=decomposed; // Not norm.setMappingCP(); because the original mapping // is most likely to be encodable as a delta. return TRUE; } } return FALSE; }
void Normalizer2DataBuilder::addComposition(UChar32 start, UChar32 end, uint32_t value) { if(norms[value].mappingType==Norm::ROUND_TRIP) { if(start!=end) { fprintf(stderr, "gennorm2 error: same round-trip mapping for " "more than 1 code point U+%04lX..U+%04lX\n", (long)start, (long)end); exit(U_INVALID_FORMAT_ERROR); } if(norms[value].cc!=0) { fprintf(stderr, "gennorm2 error: " "U+%04lX has a round-trip mapping and ccc!=0, " "not possible in Unicode normalization\n", (long)start); exit(U_INVALID_FORMAT_ERROR); } // setRoundTripMapping() ensured that there are exactly two code points. const UnicodeString &m=*norms[value].mapping; UChar32 lead=m.char32At(0); UChar32 trail=m.char32At(m.length()-1); if(getCC(lead)!=0) { fprintf(stderr, "gennorm2 error: " "U+%04lX's round-trip mapping's starter U+%04lX has ccc!=0, " "not possible in Unicode normalization\n", (long)start, (long)lead); exit(U_INVALID_FORMAT_ERROR); } // Flag for trailing character. createNorm(trail)->combinesBack=TRUE; // Insert (trail, composite) pair into compositions list for the lead character. IcuToolErrorCode errorCode("gennorm2/addComposition()"); Norm *leadNorm=createNorm(lead); UVector32 *compositions=leadNorm->compositions; int32_t i; if(compositions==NULL) { compositions=leadNorm->compositions=new UVector32(errorCode); i=0; // "insert" the first pair at index 0 } else { // Insertion sort, and check for duplicate trail characters. int32_t length; const CompositionPair *pairs=leadNorm->getCompositionPairs(length); for(i=0; i<length; ++i) { if(trail==pairs[i].trail) { fprintf(stderr, "gennorm2 error: same round-trip mapping for " "more than 1 code point (e.g., U+%04lX) to U+%04lX + U+%04lX\n", (long)start, (long)lead, (long)trail); exit(U_INVALID_FORMAT_ERROR); } if(trail<pairs[i].trail) { break; } } } compositions->insertElementAt(trail, 2*i, errorCode); compositions->insertElementAt(start, 2*i+1, errorCode); } }
int main(int argc, char *argv[]) { if (argc != 5) { printf("Usage: %s nx ny steps threads.\n", argv[0]); return 1; } int i, ti; le_point2 n = {atoi(argv[1]), atoi(argv[2])}; int steps = atoi(argv[3]); int max_threads = atoi(argv[4]); le_task task; le_material mat; le_vec2 h = {1.0, 1.0}; real dt = 0.3; le_vec2 center = {n.x / 2, n.y / 2}; char name[1000]; double t; unsigned long cc; /* pthread variables */ pthread_t threads[NUM_THREADS]; st_pthread data[NUM_THREADS]; pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); /* end of pthread variables */ le_init_material(2.0, 1.0, 1.5, &mat); task.max_threads = max_threads; task.steps = steps; le_init_task(&task, dt, h, mat, n); le_set_ball(&task, center, 10.0, 1.0); pthread_barrier_init(&b, NULL, max_threads); cc = getCC(); t = timer(); for(ti = 0; ti < max_threads; ti++) { data[ti].task = &task; data[ti].thread_num = ti; int rc = pthread_create(&(threads[ti]), &attr, le_step, (void *)(&(data[ti]))); assert(!rc); } for(ti = 0; ti < max_threads; ti++) { void *st; int rc = pthread_join(threads[ti], &st); assert(!rc);; } t = timer() - t; cc = getCC() - cc; pthread_barrier_destroy(&b); printf("%d %d %d %f ", n.x, n.y, steps, t); le_save_task(&task, "result.vtk"); le_free_task(&task); pthread_exit(NULL); }