void DumpEditor::onBufferInfo() { m_bufferInfos = m_watcher.result(); m_bufferStats = ::fwMemory::BufferManager::computeBufferStats(m_bufferInfos); m_mapper->blockSignals(true); ::fwCom::Connection::Blocker block(m_connection); for(int row = 0; row < m_list->rowCount(); row++) { m_mapper->removeMappings( m_list->cellWidget(row, 4) ); } m_list->clearContents(); m_objectsUID.clear(); int itemCount = 0; m_list->setSortingEnabled(false); m_list->setRowCount(static_cast<int>(m_bufferInfos.size())); m_list->setColumnCount(5); QColor backColor; for(const ::fwMemory::BufferManager::BufferInfoMapType::value_type& elt : m_bufferInfos) { m_objectsUID.push_back(elt.first); std::string status = "?"; std::string date = "?"; std::string lockStatus = "?"; const ::fwMemory::BufferInfo& dumpBuffInfo = elt.second; bool loaded = dumpBuffInfo.loaded; if(!loaded) { backColor = Qt::darkYellow; status = "Dumped"; } else { backColor = Qt::white; status = "-"; } bool isLock = dumpBuffInfo.lockCount() > 0; if ( isLock ) { lockStatus = "locked(" + ::fwTools::getString(dumpBuffInfo.lockCount()) +")"; } else { lockStatus = "unlocked"; } date = ::fwTools::getString(dumpBuffInfo.lastAccess.getLogicStamp()); QTableWidgetItem* currentSizeItem = new SizeTableWidgetItem( getHumanReadableSize(dumpBuffInfo.size) ); currentSizeItem->setData(Qt::UserRole, (qulonglong)dumpBuffInfo.size ); currentSizeItem->setFlags(Qt::ItemIsEnabled); currentSizeItem->setBackgroundColor(backColor); m_list->setItem(itemCount, 0, currentSizeItem ); QTableWidgetItem* statusItem = new QTableWidgetItem( QString::fromStdString(status)); statusItem->setFlags(Qt::ItemIsEnabled); statusItem->setBackgroundColor(backColor); m_list->setItem(itemCount, 1, statusItem ); QTableWidgetItem* dateItem = new QTableWidgetItem( QString::fromStdString(date)); dateItem->setFlags(Qt::ItemIsEnabled); dateItem->setBackgroundColor(backColor); m_list->setItem(itemCount, 2, dateItem ); QTableWidgetItem* lockStatusItem = new QTableWidgetItem( QString::fromStdString(lockStatus)); lockStatusItem->setFlags(Qt::ItemIsEnabled); lockStatusItem->setBackgroundColor(backColor); m_list->setItem(itemCount, 3, lockStatusItem ); QPushButton* actionItem = new QPushButton(QString::fromStdString((loaded) ? "Dump" : "Restore"), m_list); actionItem->setEnabled(!isLock && (dumpBuffInfo.size > 0) ); m_list->setCellWidget(itemCount, 4, actionItem ); QObject::connect(actionItem, SIGNAL(pressed()), m_mapper, SLOT(map())); m_mapper->setMapping(actionItem, itemCount); ++itemCount; } m_list->setSortingEnabled(true); m_mapper->blockSignals(false); m_infoEditor->reset(); m_infoEditor->resizeColumnsToContents(); }
/* * Beginning-of-function code: * * 'sp' is an array of indices in symtab for the arguments * 'cnt' is the number of arguments */ void bfcode(struct symtab **sp, int cnt) { union arglist *usym; int saveallargs = 0; int i, argofs = 0; /* * Detect if this function has ellipses and save all * argument registers onto stack. */ usym = cftnsp->sdf->dfun; while (usym && usym->type != TNULL) { if (usym->type == TELLIPSIS) { saveallargs = 1; break; } ++usym; } /* if returning a structure, move the hidden argument into a TEMP */ if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) { param_retstruct(); ++argofs; } /* recalculate the arg offset and create TEMP moves */ for (i = 0; i < cnt; i++) { if (sp[i] == NULL) continue; if ((argofs >= NARGREGS) && !xtemps) break; if (argofs > NARGREGS) { putintemp(sp[i]); } else if (sp[i]->stype == STRTY || sp[i]->stype == UNIONTY) { param_struct(sp[i], &argofs); } else if (DEUNSIGN(sp[i]->stype) == LONGLONG) { param_64bit(sp[i], &argofs, xtemps && !saveallargs); } else if (sp[i]->stype == DOUBLE || sp[i]->stype == LDOUBLE) { if (features(FEATURE_HARDFLOAT)) param_double(sp[i], &argofs, xtemps && !saveallargs); else param_64bit(sp[i], &argofs, xtemps && !saveallargs); } else if (sp[i]->stype == FLOAT) { if (features(FEATURE_HARDFLOAT)) param_float(sp[i], &argofs, xtemps && !saveallargs); else param_32bit(sp[i], &argofs, xtemps && !saveallargs); } else { param_32bit(sp[i], &argofs, xtemps && !saveallargs); } } /* if saveallargs, save the rest of the args onto the stack */ while (saveallargs && argofs < NARGREGS) { NODE *p, *q; int off = ARGINIT/SZINT + argofs; q = block(REG, NIL, NIL, INT, 0, 0); regno(q) = R0 + argofs++; p = block(REG, NIL, NIL, INT, 0, 0); regno(p) = FPREG; p = block(PLUS, p, bcon(4*off), INT, 0, 0); p = block(UMUL, p, NIL, INT, 0, 0); p = buildtree(ASSIGN, p, q); ecomp(p); } }
//////////////////////////////////////////////////////////////////////////////////////////////////////// //calculate hog features //based on code from http://www.mathworks.com/matlabcentral/fileexchange/33863 cv::Mat HOGfeatures(cv::Mat & pixels, int nb_bins, double cheight, double cwidth, int block_rows, int block_cols, bool orient, double clip_val) { //const double PI = 3.1415926536; bool grayscale; //img must be uchar if (pixels.type() == CV_8UC1) { grayscale = 1; } else if (pixels.type() == CV_8UC3) { grayscale = 0; } else { std::cerr << "Image is not uchar, cannot calculate HOG!!!" << std::endl; return cv::Mat(); } /*if (!pixels.isContinuous()) { cv::Mat temp = pixels.clone(); pixels = temp; if (!pixels.isContinuous()) { std::cerr << "Memory error, cannot allocate a continuous array for HOG calc!" << std::endl; return cv::Mat(); } } unsigned char * pixels = img.data;*/ int img_width = pixels.cols; int img_height = pixels.rows; int hist1= 2+ceil(-0.5 + img_height/cheight); int hist2= 2+ceil(-0.5 + img_width/cwidth); double bin_size = (1+(orient==1))*PI/nb_bins; cv::Mat features((hist1-2-(block_rows-1))*(hist2-2-(block_cols-1))*nb_bins*block_rows*block_cols, 1, CV_32FC1); float dx[3], dy[3], grad_or, grad_mag, temp_mag; float Xc, Yc, Oc, block_norm; int x1, x2, y1, y2, bin1, bin2; int des_indx = 0; std::vector<std::vector<std::vector<double> > > h(hist1, std::vector<std::vector<double> > (hist2, std::vector<double> (nb_bins, 0.0) ) ); std::vector<std::vector<std::vector<double> > > block(block_rows, std::vector<std::vector<double> > (block_cols, std::vector<double> (nb_bins, 0.0) ) ); std::vector<cv::Mat> pixel_vec; if (!grayscale) { cv::split(pixels, pixel_vec); } //Calculate gradients (zero padding) for(unsigned int y=0; y<img_height; y++) { for(unsigned int x=0; x<img_width; x++) { if (grayscale == 1) { if (x==0) { dx[0] = pixels.at<unsigned char>(y , x+1); } else { if (x==img_width-1) { dx[0] = -pixels.at<unsigned char>(y , x-1); } else { dx[0] = pixels.at<unsigned char>(y, x+1) - pixels.at<unsigned char>(y , x-1); } } if (y==0) { dy[0] = -pixels.at<unsigned char>(y+1, x); } else{ if (y==img_height-1) { dy[0] = pixels.at<unsigned char>(y-1, x); } else { dy[0] = -pixels.at<unsigned char>(y+1, x) + pixels.at<unsigned char>(y-1, x); } } } else { if(x==0) { dx[0] = pixel_vec[0].at<unsigned char>(y , x+1); dx[1] = pixel_vec[1].at<unsigned char>(y , x+1); dx[2] = pixel_vec[2].at<unsigned char>(y , x+1); } else { if (x==img_width-1) { dx[0] = -pixel_vec[0].at<unsigned char>(y , x-1); dx[1] = -pixel_vec[1].at<unsigned char>(y , x-1); dx[2] = -pixel_vec[2].at<unsigned char>(y , x-1); } else { dx[0] = pixel_vec[0].at<unsigned char>(y, x+1) - pixel_vec[0].at<unsigned char>(y , x-1); dx[1] = pixel_vec[1].at<unsigned char>(y, x+1) - pixel_vec[1].at<unsigned char>(y , x-1); dx[2] = pixel_vec[2].at<unsigned char>(y, x+1) - pixel_vec[2].at<unsigned char>(y , x-1); } } if(y==0) { dy[0] = -pixel_vec[0].at<unsigned char>(y+1, x); dy[1] = -pixel_vec[1].at<unsigned char>(y+1, x); dy[2] = -pixel_vec[2].at<unsigned char>(y+1, x); } else { if (y==img_height-1) { dy[0] = pixel_vec[0].at<unsigned char>(y-1, x); dy[1] = pixel_vec[1].at<unsigned char>(y-1, x); dy[2] = pixel_vec[2].at<unsigned char>(y-1, x); } else { dy[0] = -pixel_vec[0].at<unsigned char>(y+1, x) + pixel_vec[0].at<unsigned char>(y-1, x); dy[1] = -pixel_vec[1].at<unsigned char>(y+1, x) + pixel_vec[1].at<unsigned char>(y-1, x); dy[2] = -pixel_vec[2].at<unsigned char>(y+1, x) + pixel_vec[2].at<unsigned char>(y-1, x); } } } grad_mag = sqrt(dx[0]*dx[0] + dy[0]*dy[0]); grad_or= atan2(dy[0], dx[0]); if (grayscale == 0) { temp_mag = grad_mag; for (unsigned int cli=1;cli<3;++cli) { temp_mag= sqrt(dx[cli]*dx[cli] + dy[cli]*dy[cli]); if (temp_mag>grad_mag) { grad_mag=temp_mag; grad_or= atan2(dy[cli], dx[cli]); } } } if (grad_or<0) grad_or+=PI + (orient==1) * PI; // trilinear interpolation bin1 = (int)floor(0.5 + grad_or/bin_size) - 1; bin2 = bin1 + 1; x1 = (int)floor(0.5+ x/cwidth); x2 = x1+1; y1 = (int)floor(0.5+ y/cheight); y2 = y1 + 1; Xc = (x1+1-1.5)*cwidth + 0.5; Yc = (y1+1-1.5)*cheight + 0.5; Oc = (bin1+1+1-1.5)*bin_size; if (bin2==nb_bins){ bin2=0; } if (bin1<0){ bin1=nb_bins-1; } h[y1][x1][bin1]= h[y1][x1][bin1] + grad_mag*(1-((x+1-Xc)/cwidth))*(1-((y+1-Yc)/cheight))*(1-((grad_or-Oc)/bin_size)); h[y1][x1][bin2]= h[y1][x1][bin2] + grad_mag*(1-((x+1-Xc)/cwidth))*(1-((y+1-Yc)/cheight))*(((grad_or-Oc)/bin_size)); h[y2][x1][bin1]= h[y2][x1][bin1] + grad_mag*(1-((x+1-Xc)/cwidth))*(((y+1-Yc)/cheight))*(1-((grad_or-Oc)/bin_size)); h[y2][x1][bin2]= h[y2][x1][bin2] + grad_mag*(1-((x+1-Xc)/cwidth))*(((y+1-Yc)/cheight))*(((grad_or-Oc)/bin_size)); h[y1][x2][bin1]= h[y1][x2][bin1] + grad_mag*(((x+1-Xc)/cwidth))*(1-((y+1-Yc)/cheight))*(1-((grad_or-Oc)/bin_size)); h[y1][x2][bin2]= h[y1][x2][bin2] + grad_mag*(((x+1-Xc)/cwidth))*(1-((y+1-Yc)/cheight))*(((grad_or-Oc)/bin_size)); h[y2][x2][bin1]= h[y2][x2][bin1] + grad_mag*(((x+1-Xc)/cwidth))*(((y+1-Yc)/cheight))*(1-((grad_or-Oc)/bin_size)); h[y2][x2][bin2]= h[y2][x2][bin2] + grad_mag*(((x+1-Xc)/cwidth))*(((y+1-Yc)/cheight))*(((grad_or-Oc)/bin_size)); } } //Block normalization for(unsigned int x=1; x<hist2-block_cols; x++) { for (unsigned int y=1; y<hist1-block_rows; y++) { block_norm=0; for (unsigned int i=0; i<block_rows; i++) { for(unsigned int j=0; j<block_cols; j++) { for(unsigned int k=0; k<nb_bins; k++) { block_norm+=h[y+i][x+j][k]*h[y+i][x+j][k]; } } } block_norm=sqrt(block_norm); for (unsigned int i=0; i<block_rows; i++) { for(unsigned int j=0; j<block_cols; j++) { for(unsigned int k=0; k<nb_bins; k++) { if (block_norm>0) { block[i][j][k]=h[y+i][x+j][k]/block_norm; if (block[i][j][k]>clip_val) block[i][j][k]=clip_val; } } } } block_norm=0; for (unsigned int i=0; i<block_rows; i++) { for(unsigned int j=0; j<block_cols; j++) { for(unsigned int k=0; k<nb_bins; k++) { block_norm+=block[i][j][k]*block[i][j][k]; } } } block_norm=sqrt(block_norm); for (unsigned int i=0; i<block_rows; i++) { for(unsigned int j=0; j<block_cols; j++) { for(unsigned int k=0; k<nb_bins; k++) { if (block_norm>0) { features.at<float>(des_indx,0) = block[i][j][k]/block_norm; } else { features.at<float>(des_indx,0) = 0.0; } des_indx++; } } } } } return features; }
signed char CWorld::GetHeightPoint2( const CPointBase & pt, DWORD & wBlockFlags, bool fHouseCheck ) // Height of player who walked to X/Y/OLDZ { ADDTOCALLSTACK("CWorld::GetHeightPoint2"); // Given our coords at pt including pt.m_z // What is the height that gravity would put me at should i step hear ? // Assume my head height is PLAYER_HEIGHT/2 // ARGS: // pt = the point of interest. // pt.m_z = my starting altitude. // wBlockFlags = what we can pass thru. doors, water, walls ? // CAN_C_GHOST = Moves thru doors etc. - CAN_I_DOOR // CAN_C_SWIM = walk thru water - CAN_I_WATER // CAN_C_WALK = it is possible that i can step up. - CAN_I_PLATFORM // CAN_C_PASSWALLS = walk through all blocking items - CAN_I_BLOCK // CAN_C_FLY = gravity does not effect me. - CAN_I_CLIMB // CAN_C_FIRE_IMMUNE = i can walk into lava etc. - CAN_I_FIRE // pRegion = possible regional effects. (multi's) // RETURN: // pt.m_z = Our new height at pt.m_x,pt.m_y // wBlockFlags = our blocking flags at the given location. CAN_I_WATER,CAN_C_WALK,CAN_FLY,CAN_SPIRIT, // CAN_C_INDOORS = i am covered from the sky // // ??? NOTE: some creatures should be taller than others !!! DWORD dwCan = wBlockFlags; CGrayMapBlockState block(wBlockFlags, pt.m_z, PLAYER_HEIGHT); GetHeightPoint2( pt, block, fHouseCheck ); // Pass along my results. wBlockFlags = block.m_Bottom.m_dwBlockFlags; if (block.m_Top.m_dwBlockFlags) { wBlockFlags |= CAN_I_ROOF; // we are covered by something. // Do not check for landtiles to block me. We pass through if statics are under them if (block.m_Top.m_dwTile > TERRAIN_QTY) { // If this tile possibly blocks me, roof cannot block me if (block.m_Top.m_dwBlockFlags &~(CAN_I_ROOF)) { if (block.m_Top.m_z < block.m_Bottom.m_z + PLAYER_HEIGHT) wBlockFlags |= CAN_I_BLOCK; // we can't fit under this! } } } if (( block.m_Lowest.m_dwBlockFlags & CAN_I_HOVER ) || ( block.m_Bottom.m_dwBlockFlags & CAN_I_HOVER ) || ( block.m_Top.m_dwBlockFlags & CAN_I_HOVER )) { if ( dwCan & CAN_C_HOVER ) wBlockFlags = 0; // we can hover over this else wBlockFlags &= ~CAN_I_HOVER; // we don't have the ability to fly } if (( wBlockFlags & ( CAN_I_CLIMB|CAN_I_PLATFORM) ) && ( dwCan & CAN_C_WALK )) { wBlockFlags &= ~CAN_I_CLIMB; wBlockFlags |= CAN_I_PLATFORM; // not really true but hack it anyhow. return( block.m_Bottom.m_z ); } if ( dwCan & CAN_C_FLY ) return( pt.m_z ); return( block.m_Bottom.m_z ); }
int32_t ompi_datatype_create_darray(int size, int rank, int ndims, int const* gsize_array, int const* distrib_array, int const* darg_array, int const* psize_array, int order, const ompi_datatype_t* oldtype, ompi_datatype_t** newtype) { ompi_datatype_t *lastType; ptrdiff_t orig_extent, *st_offsets = NULL; int i, start_loop, end_loop, step; int *coords = NULL, rc = OMPI_SUCCESS; /* speedy corner case */ if (ndims < 1) { /* Don't just return MPI_DATATYPE_NULL as that can't be MPI_TYPE_FREE()ed, and that seems bad */ *newtype = ompi_datatype_create(0); ompi_datatype_add(*newtype, &ompi_mpi_datatype_null.dt, 0, 0, 0); return MPI_SUCCESS; } rc = ompi_datatype_type_extent(oldtype, &orig_extent); if (MPI_SUCCESS != rc) goto cleanup; /* calculate position in grid using row-major ordering */ { int tmp_rank = rank, procs = size; coords = (int *) malloc(ndims * sizeof(int)); for (i = 0 ; i < ndims ; i++) { procs = procs / psize_array[i]; coords[i] = tmp_rank / procs; tmp_rank = tmp_rank % procs; } } st_offsets = (ptrdiff_t *) malloc(ndims * sizeof(ptrdiff_t)); /* duplicate type to here to 1) deal with constness without casting and 2) eliminate need to for conditional destroy below. Lame, yes. But cleaner code all around. */ rc = ompi_datatype_duplicate(oldtype, &lastType); if (OMPI_SUCCESS != rc) goto cleanup; /* figure out ordering issues */ if (MPI_ORDER_C == order) { start_loop = ndims - 1 ; step = -1; end_loop = -1; } else { start_loop = 0 ; step = 1; end_loop = ndims; } /* Build up array */ for (i = start_loop; i != end_loop; i += step) { int nprocs, tmp_rank; switch(distrib_array[i]) { case MPI_DISTRIBUTE_BLOCK: rc = block(gsize_array, i, ndims, psize_array[i], coords[i], darg_array[i], order, orig_extent, lastType, newtype, st_offsets+i); break; case MPI_DISTRIBUTE_CYCLIC: rc = cyclic(gsize_array, i, ndims, psize_array[i], coords[i], darg_array[i], order, orig_extent, lastType, newtype, st_offsets+i); break; case MPI_DISTRIBUTE_NONE: /* treat it as a block distribution on 1 process */ if (order == MPI_ORDER_C) { nprocs = psize_array[i]; tmp_rank = coords[i]; } else { nprocs = 1; tmp_rank = 0; } rc = block(gsize_array, i, ndims, nprocs, tmp_rank, MPI_DISTRIBUTE_DFLT_DARG, order, orig_extent, lastType, newtype, st_offsets+i); break; default: rc = MPI_ERR_ARG; } ompi_datatype_destroy(&lastType); /* need to destroy the old type even in error condition, so don't check return code from above until after cleanup. */ if (MPI_SUCCESS != rc) goto cleanup; lastType = *newtype; } /* set displacement and UB correctly. Use struct instead of resized for same reason as subarray */ { ptrdiff_t displs[3]; ompi_datatype_t *types[3]; int tmp_size, blength[3] = { 1, 1, 1}; displs[1] = st_offsets[start_loop]; tmp_size = 1; for (i = start_loop + step ; i != end_loop ; i += step) { tmp_size *= gsize_array[i - step]; displs[1] += tmp_size * st_offsets[i]; } displs[0] = 0; displs[1] *= orig_extent; displs[2] = orig_extent; for (i = 0 ; i < ndims ; i++) { displs[2] *= gsize_array[i]; } types[0] = MPI_LB; types[1] = lastType; types[2] = MPI_UB; rc = ompi_datatype_create_struct(3, blength, displs, types, newtype); ompi_datatype_destroy(&lastType); /* need to destroy the old type even in error condition, so don't check return code from above until after cleanup. */ if (MPI_SUCCESS != rc) goto cleanup; } cleanup: if (NULL != st_offsets) free(st_offsets); if (NULL != coords) free(coords); return OMPI_SUCCESS; }
void CachedQuarkletProblem<PROBLEM>::add_level (const Index& lambda, //InfiniteVector<double, Index>& w, Vector<double>& w, const int j, const double factor, const int J, const CompressionStrategy strategy, const int jmax, const int pmax, const double a, const double b) const { // cout << "bin in addlevel drin" << endl; // cout << lambda << endl; // cout << j << endl; // WaveletBasis mybasis(basis()); const int minplevel = std::max(0, lambda.p() + 1 - (int) pow(2,(J-b*abs(j-lambda.j())/a))); const int maxplevel = std::min(lambda.p() - 1 + (int) pow(2,(J-b*abs(j-lambda.j())/a)), pmax); const int lambda_num = number(lambda, jmax); //cout << lambda << ": " << lambda_num << endl; // search for column 'lambda' typedef std::list<Index> IntersectingList; typename ColumnCache::iterator col_lb(entries_cache.lower_bound(lambda_num)); typename ColumnCache::iterator col_it(col_lb); if (col_lb == entries_cache.end() || entries_cache.key_comp()(lambda_num,col_lb->first)) { // insert a new column typedef typename ColumnCache::value_type value_type; col_it = entries_cache.insert(col_lb, value_type(lambda_num, Column())); } Column& col(col_it->second); // check wether the level has already been calculated typename Column::iterator lb(col.lower_bound(j)); typename Column::iterator it(lb); if (lb == col.end() || col.key_comp()(j, lb->first)) { // no entries have ever been computed for this column and this level // cout << "keine Einträge berechnet" << endl; // insert a new level typedef typename Column::value_type value_type; it = col.insert(lb, value_type(j, Block())); Block& block(it->second); IntersectingList nus; //DKR strategy // cout << lambda << endl; // cout << j << endl; // cout << J << endl; //cout << minplevel << endl; //cout << maxplevel << endl; for(int p = minplevel; p<=maxplevel; ++p){ // cout << "Hallo" << endl; intersecting_wavelets(basis(), lambda, std::max(j, basis().j0()), j == (basis().j0()-1), nus, p); // do the rest of the job const double d1 = problem->D(lambda); // cout << d1 << endl; for (typename IntersectingList::const_iterator it2(nus.begin()), itend2(nus.end()); it2 != itend2; ++it2) { const double entry = problem->a(*it2, lambda); // cout << *it2 << ", " << entry << endl; typedef typename Block::value_type value_type_block; if (entry != 0.) { // cout << "ja3" << endl; block.insert(block.end(), value_type_block(number(*it2,jmax), entry)); //w.add_coefficient(*it2, (entry / (d1 * problem->D(*it2))) * factor); // cout << *it2 << ": " << (*it2).number() << endl; // cout << number(*it2,jmax) << endl; // cout << w.size() << endl; w[number(*it2,jmax)] += (entry / (d1*problem->D(*it2))) * factor; //cout << "ja5" << endl; } // cout << "ja1" << endl; } // cout << "ja2" << endl; } } else { //cout << "Einträge schon berechnet" << endl; // level already exists --> extract level from cache //cout << "Iterator: " << it->first << endl; Block& block(it->second); const double d1 = problem->D(lambda); //cout << "Länge w: " << w.size() << endl; for (typename Block::const_iterator it2(block.begin()), itend2(block.end()); it2 != itend2; ++it2) { // w.add_coefficient(*(problem->basis().get_wavelet(it2->first)), // (it2->second / (d1 * problem->D( *(problem->basis().get_wavelet(it2->first)) ))) * factor); //cout << it2->second << endl; //cout << it2->first << endl; w[it2->first] += (it2->second / (d1*problem->D(*(problem->basis().get_wavelet(it2->first))))) * factor; } }// end else }
void IsometricTileRenderer::renderTile(const TilePos& tile_pos, RGBAImage& tile) { // some vars, set correct image size int block_size = images->getBlockSize(); tile.setSize(getTileSize(), getTileSize()); // get the maximum count of water blocks // blitted about each over, until they are nearly opaque int max_water = images->getMaxWaterPreblit(); // all visible blocks which are rendered in this tile std::set<RenderBlock> blocks; // iterate over the highest blocks in the tile // we use as tile position tile_pos+tile_offset because the offset means that // we treat the tile position as tile_pos, but it's actually tile_pos+tile_offset for (TileTopBlockIterator it(tile_pos, block_size, tile_width); !it.end(); it.next()) { // water render behavior n1: // are we already in a row of water? bool in_water = false; // water render behavior n2: // water counter, how many water blocks are at the moment in this row? int water = 0; // the render block objects in our current block row std::set<RenderBlock> row_nodes; // then iterate over the blocks, which are on the tile at the same position, // beginning from the highest block for (BlockRowIterator block(it.current); !block.end(); block.next()) { // get current chunk position mc::ChunkPos current_chunk_pos(block.current); // check if current chunk is not null // and if the chunk wasn't replaced in the cache (i.e. position changed) if (current_chunk == nullptr || current_chunk->getPos() != current_chunk_pos) // get chunk if not //if (!state.world->hasChunkSection(current_chunk, block.current.y)) // continue; current_chunk = world->getChunk(current_chunk_pos); if (current_chunk == nullptr) { // here is nothing (= air), // so reset state if we are in water in_water = false; continue; } // get local block position mc::LocalBlockPos local(block.current); // now get block id uint16_t id = current_chunk->getBlockID(local); // air is completely transparent so continue if (id == 0) { in_water = false; continue; } // now get the block data uint16_t data = current_chunk->getBlockData(local); // check if the render mode hides this block if (render_mode->isHidden(block.current, id, data)) continue; bool is_water = (id == 8 || id == 9) && data == 0; if (is_water && !use_preblit_water) { // water render behavior n1: // render only the top sides of the water blocks // and darken the ground with the lighting data // used for lighting rendermode // if we are already in water, skip checking this water block if (is_water && in_water) continue; in_water = is_water; } else if (use_preblit_water) { // water render behavior n2: // render the top side of every water block // have also preblit water blocks to skip redundant alphablitting // no lighting is needed because the 'opaque-water-effect' // is created by blitting the top sides of the water blocks // one above the other if (!is_water) { // if not water, reset the counter water = 0; } else { water++; // when we have enough water in a row // we can stop searching more blocks // and replace the already added render blocks with a preblit water block if (water > max_water) { std::set<RenderBlock>::const_iterator it = row_nodes.begin(); // iterate through the render blocks in this row while (it != row_nodes.end()) { std::set<RenderBlock>::const_iterator current = it++; // check if we have reached the top most water block if (it == row_nodes.end() || (it->id != 8 && it->id != 9)) { RenderBlock top = *current; row_nodes.erase(current); // check for neighbors mc::Block south, west; south = getBlock(top.pos + mc::DIR_SOUTH); west = getBlock(top.pos + mc::DIR_WEST); id = 8; data = OPAQUE_WATER; bool neighbor_south = !south.isFullWater(); if (neighbor_south) // data |= DATA_SOUTH; data |= OPAQUE_WATER_SOUTH; bool neighbor_west = !west.isFullWater(); if (neighbor_west) // data |= DATA_WEST; data |= OPAQUE_WATER_WEST; // get image and replace the old render block with this //top.image = images->getOpaqueWater(neighbor_south, // neighbor_west); top.image = images->getBlock(id, data); // don't forget the render mode render_mode->draw(top.image, top.pos, id, data); row_nodes.insert(top); break; } else { // water render block row_nodes.erase(current); } } break; } } } // check for special data (neighbor related) // get block image, check for transparency, create render block... data = checkNeighbors(block.current, id, data); //if (is_water && (data & DATA_WEST) && (data & DATA_SOUTH)) // continue; RGBAImage image; bool transparent = images->isBlockTransparent(id, data); // check for biome data if (Biome::isBiomeBlock(id, data)) image = images->getBiomeBlock(id, data, getBiomeOfBlock(block.current, current_chunk)); else image = images->getBlock(id, data); RenderBlock node; node.x = it.draw_x; node.y = it.draw_y; node.pos = block.current; node.image = image; node.id = id; node.data = data; // let the render mode do their magic with the block image render_mode->draw(node.image, node.pos, id, data); // insert into current row row_nodes.insert(node); // if this block is not transparent, then break if (!transparent) break; } // iterate through the created render blocks for (std::set<RenderBlock>::const_iterator it = row_nodes.begin(); it != row_nodes.end(); ++it) { std::set<RenderBlock>::const_iterator next = it; next++; // insert render block to if (next == row_nodes.end()) { blocks.insert(*it); } else { // skip unnecessary leaves if (it->id == 18 && next->id == 18 && (next->data & 3) == (it->data & 3)) continue; blocks.insert(*it); } } } // now blit all blocks for (std::set<RenderBlock>::const_iterator it = blocks.begin(); it != blocks.end(); ++it) { tile.alphaBlit(it->image, it->x, it->y); } }
// input/ouput handler function to be called on thread void *io_handler(void *param, int socket_fd) { char command[MAXCOMMANDSIZE]; // For receiving commands from user int exitsignal; // If user wants to end the application (Command: EXIT, value: 8) // Main process loop for client while(fgets(command, sizeof command, stdin)) { // Manual removal of newline character int len = strlen(command); if (len > 0 && command[len-1] == '\n') { command[len-1] = '\0'; } allCaps(command); // parse the command, check if either single or double arg command int token_count = 0; int idx = 1; char* pch; char s[2][MAXCOMMANDSIZE]; memset(s[0], "", MAXCOMMANDSIZE); memset(s[1], "", MAXCOMMANDSIZE); int isnul = strlen(command); if (isnul == 0) continue; pch = strtok(command, " "); strcpy(s[0], pch); while (pch != NULL) { pch = strtok(NULL, " "); if (pch != NULL) { strcpy(s[1], pch); idx++; if (idx > 1) break; } } if (idx == 1) { char* c1 = &s[0]; if(!strcmp(c1, "EXIT")) { /* clean up */ printf("Terminating server...\n"); close(socket_fd); exit(0); } else if(!strcmp(c1, "START")){ ready = 1; enable_stats = 1; if (abs_start == 0) abs_start = 1; else printf("Server ready: waiting for connections...\n"); } else if(!strcmp(c1, "STATS")){ if (enable_stats == 0) printf ("Server still inactive\n"); else stats(); } else if (!strcmp(c1, "END")){ printf ("Server terminating...\n"); end(); printf ("...done\n"); } else { fprintf(stderr, "Unknown command: %s...\n", command); } } else if (idx == 2) { char* c1 = &s[0]; char* c2 = &s[1]; if(!strcmp(c1, "BLOCK")){ int socket = atoi(c2); printf("Blocking socket %d\n", socket); block(socket); } else if(!strcmp(c1, "UNBLOCK")){ int socket = atoi(c2); printf("Unblocking socket %d\n", socket); unblock(socket); } else if(!strcmp(c1, "THROWOUT")) { int socket = atoi(c2); printf("Throwing out socket %d\n", socket); throwout(socket); } else { fprintf(stderr, "Unknown command: %s...\n", command); } } else { fprintf(stderr, "Unknown command: %s...\n", command); } } return NULL; }
void GetBlockTemplateContext::updateWork() { MutexLocker locker(&_mutex); _blockTemplateExists = false; const char *error; json_error_t jsonError; json_t *response = json_loads(_response.c_str(), 0, &jsonError); if (!response) { logFormattedWrite(_log, "getblocktemplate response JSON parsing error: %s", _response.c_str()); return; } std::unique_ptr<blktemplate_t, std::function<void(blktemplate_t*)>> block( blktmpl_create(), [](blktemplate_t *b) { blktmpl_free(b); }); for (unsigned i = 0; i < _blocksNum; i++) { if (_blocks[i]) { blktmpl_free(_blocks[i]); _blocks[i] = 0; } } error = blktmpl_add_jansson(block.get(), response, time(0)); json_delete(response); if (error) { logFormattedWrite(_log, "Error %s", error); return; } for (unsigned i = 0; i < _blocksNum; i++) { unsigned char data[80]; _cbscript_t opt_coinbase_script; bool newcb; error = set_b58addr(_wallet, &opt_coinbase_script); if (error) { logFormattedWrite(_log, "Error %s", error); return; } _blocks[i] = blktmpl_duplicate(block.get()); uint64_t num = blkmk_init_generation2(_blocks[i], opt_coinbase_script.data, opt_coinbase_script.sz, &newcb); uint32_t extraNonce = (_extraNonce << 16) + i; ssize_t coinbaseAppendResult = blkmk_append_coinbase_safe(_blocks[i], &extraNonce, sizeof(extraNonce)); if (coinbaseAppendResult < 0) { logFormattedWrite(_log, "cannot add extra nonce (error %i)", (int)coinbaseAppendResult); return; } size_t dataSize = blkmk_get_data(_blocks[i], data, sizeof(data), time(0), NULL, &_dataId); if (!(dataSize >= 76 && dataSize <= sizeof(data))) { logFormattedWrite(_log, "getblocktemplate response decoding error (invalid size)"); return; } } if (_height != block->height) logFormattedWrite(_log, "new block detected: %u", block->height-1); _height = block->height; _difficulty = difficultyFromBits(*(uint32_t*)(&block->diffbits)); _blockTemplateExists = true; }
/* Cover both external declarations, functions, and local declarations (with * optional initialization code) inside functions. */ struct block *declaration(struct block *parent) { struct typetree *base; enum symtype symtype; enum linkage linkage; int stc = '$'; base = declaration_specifiers(&stc); switch (stc) { case EXTERN: symtype = SYM_DECLARATION; linkage = LINK_EXTERN; break; case STATIC: symtype = SYM_TENTATIVE; linkage = LINK_INTERN; break; case TYPEDEF: symtype = SYM_TYPEDEF; linkage = LINK_NONE; break; default: if (!ns_ident.current_depth) { symtype = SYM_TENTATIVE; linkage = LINK_EXTERN; } else { symtype = SYM_DEFINITION; linkage = LINK_NONE; } break; } while (1) { struct definition *def; const char *name = NULL; const struct typetree *type; struct symbol *sym; type = declarator(base, &name); if (!name) { consume(';'); return parent; } sym = sym_add(&ns_ident, name, type, symtype, linkage); if (ns_ident.current_depth) { assert(ns_ident.current_depth > 1); def = current_func(); def->locals = sym_list_add(def->locals, sym); } switch (peek().token) { case ';': consume(';'); return parent; case '=': if (sym->symtype == SYM_DECLARATION) { error("Extern symbol '%s' cannot be initialized.", sym->name); exit(1); } if (!sym->depth && sym->symtype == SYM_DEFINITION) { error("Symbol '%s' was already defined.", sym->name); exit(1); } consume('='); sym->symtype = SYM_DEFINITION; if (sym->linkage == LINK_NONE) { assert(parent); parent = initializer(parent, var_direct(sym)); } else { assert(sym->depth || !parent); def = push_back_definition(sym); initializer(def->body, var_direct(sym)); } assert(size_of(&sym->type) > 0); if (peek().token != ',') { consume(';'); return parent; } break; case '{': { int i; if (!is_function(&sym->type) || sym->depth) { error("Invalid function definition."); exit(1); } assert(!parent); assert(sym->linkage != LINK_NONE); sym->symtype = SYM_DEFINITION; def = push_back_definition(sym); push_scope(&ns_ident); define_builtin__func__(sym->name); for (i = 0; i < nmembers(&sym->type); ++i) { name = get_member(&sym->type, i)->name; type = get_member(&sym->type, i)->type; symtype = SYM_DEFINITION; linkage = LINK_NONE; if (!name) { error("Missing parameter name at position %d.", i + 1); exit(1); } def->params = sym_list_add(def->params, sym_add(&ns_ident, name, type, symtype, linkage)); } parent = block(def->body); pop_scope(&ns_ident); return parent; } default: break; } consume(','); } }
bool isStopped() { synchronized block(*this); return stopped; }
void Consumer::ensureSetup() { if (!topicPtr.load(std::memory_order_acquire)) { CriticalBlock block(lock); if (!topicPtr.load(std::memory_order_relaxed)) { initFileOffsetIfNotExist(); std::string errStr; RdKafka::Conf* globalConfig = RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL); if (globalConfig) { // Set global configuration parameters, used mainly at the consumer level globalConfig->set("metadata.broker.list", brokers, errStr); globalConfig->set("compression.codec", "snappy", errStr); globalConfig->set("queued.max.messages.kbytes", "10000000", errStr); globalConfig->set("fetch.message.max.bytes", "10000000", errStr); // Set any global configurations from file, allowing // overrides of above settings applyConfig("kafka_global.conf", globalConfig, traceLevel); // Set consumer callbacks globalConfig->set("event_cb", static_cast<RdKafka::EventCb*>(this), errStr); // Create the consumer consumerPtr = RdKafka::Consumer::create(globalConfig, errStr); if (consumerPtr) { RdKafka::Conf* topicConfPtr = RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC); // Set the per-topic configuration parameters topicConfPtr->set("group.id", consumerGroup, errStr); topicConfPtr->set("auto.offset.reset", "smallest", errStr); // Set any topic configurations from file, allowing // overrides of above settings std::string confName = "kafka_consumer_topic_" + topic + ".conf"; applyConfig(confName.c_str(), topicConfPtr, traceLevel); // Ensure that some items are set a certain way // by setting them after loading the external conf topicConfPtr->set("auto.commit.enable", "false", errStr); // Create the topic topicPtr.store(RdKafka::Topic::create(consumerPtr, topic, topicConfPtr, errStr), std::memory_order_release); if (!topicPtr) { throw MakeStringException(-1, "Kafka: Unable to create consumer topic object for topic '%s'; error: '%s'", topic.c_str(), errStr.c_str()); } } else { throw MakeStringException(-1, "Kafka: Unable to create consumer object for brokers '%s'; error: '%s'", brokers.c_str(), errStr.c_str()); } } else { throw MakeStringException(-1, "Kafka: Unable to create consumer global configuration object for brokers '%s'; error: '%s'", brokers.c_str(), errStr.c_str()); } } } }
void Publisher::ensureSetup() { if (!topicPtr.load(std::memory_order_acquire)) { CriticalBlock block(lock); if (!topicPtr.load(std::memory_order_relaxed)) { std::string errStr; RdKafka::Conf* globalConfig = RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL); if (globalConfig) { // Set global configuration parameters, used mainly at the producer level globalConfig->set("metadata.broker.list", brokers, errStr); globalConfig->set("queue.buffering.max.messages", "1000000", errStr); globalConfig->set("compression.codec", "snappy", errStr); globalConfig->set("message.send.max.retries", "3", errStr); globalConfig->set("retry.backoff.ms", "500", errStr); // Set any global configurations from file, allowing // overrides of above settings applyConfig("kafka_global.conf", globalConfig, traceLevel); // Set producer callbacks globalConfig->set("event_cb", static_cast<RdKafka::EventCb*>(this), errStr); globalConfig->set("dr_cb", static_cast<RdKafka::DeliveryReportCb*>(this), errStr); // Create the producer producerPtr = RdKafka::Producer::create(globalConfig, errStr); if (producerPtr) { RdKafka::Conf* topicConfPtr = RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC); // Set any topic configurations from file std::string confName = "kafka_publisher_topic_" + topic + ".conf"; applyConfig(confName.c_str(), topicConfPtr, traceLevel); // Create the topic topicPtr.store(RdKafka::Topic::create(producerPtr, topic, topicConfPtr, errStr), std::memory_order_release); if (topicPtr) { // Start the attached background poller pollerPtr->start(); } else { throw MakeStringException(-1, "Kafka: Unable to create producer topic object for topic '%s'; error: '%s'", topic.c_str(), errStr.c_str()); } } else { throw MakeStringException(-1, "Kafka: Unable to create producer object for brokers '%s'; error: '%s'", brokers.c_str(), errStr.c_str()); } } else { throw MakeStringException(-1, "Kafka: Unable to create producer global configuration object for brokers '%s'; error: '%s'", brokers.c_str(), errStr.c_str()); } } } }
void ScCodeEditor::matchBrackets() { mBracketSelections.clear(); QTextCursor cursor(textCursor()); QTextBlock block( cursor.block() ); int posInBlock = cursor.positionInBlock(); TokenIterator it(block); while (it.isValid() && it.block() == block) { const Token & token = *it; if (token.positionInBlock > posInBlock) { it = TokenIterator(); break; } else if ( (token.positionInBlock == posInBlock && token.type == Token::OpeningBracket) || (token.positionInBlock == posInBlock - 1 && token.type == Token::ClosingBracket) ) break; ++it; } if (!it.isValid() || it.block() != block) { updateExtraSelections(); return; } BracketPair match; matchBracket( it, match ); if( match.first.isValid() && match.second.isValid() ) { const Token & tok1 = *match.first; const Token & tok2 = *match.second; if ( (tok1.character == '(' && tok2.character == ')') || (tok1.character == '[' && tok2.character == ']') || (tok1.character == '{' && tok2.character == '}') ){ QTextEdit::ExtraSelection selection; selection.format = mBracketHighlight; cursor.setPosition(match.first.position()); cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor); selection.cursor = cursor; mBracketSelections.append(selection); cursor.setPosition(match.second.position()); cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor); selection.cursor = cursor; mBracketSelections.append(selection); } else { QTextEdit::ExtraSelection selection; selection.format = mBracketMismatchFormat; cursor.setPosition(match.first.position()); cursor.setPosition(match.second.position()+1, QTextCursor::KeepAnchor); selection.cursor = cursor; mBracketSelections.append(selection); } } else { if ( it.type() == Token::OpeningBracket ) { cursor.setPosition(it.position()); cursor.movePosition(QTextCursor::End, QTextCursor::KeepAnchor); } else { cursor.setPosition(it.position() + 1); cursor.movePosition(QTextCursor::Start, QTextCursor::KeepAnchor); } QTextEdit::ExtraSelection selection; selection.format = mBracketMismatchFormat; selection.cursor = cursor; mBracketSelections.append(selection); } updateExtraSelections(); }
void main_help() { cout << block(main_help_str, 0, 80) << endl; }
const Block::header_t* header() const { return &(block()->_header); }
/* clocal() is called to do local transformations on * an expression tree preparitory to its being * written out in intermediate code. * * the major essential job is rewriting the * automatic variables and arguments in terms of * REG and OREG nodes * conversion ops which are not necessary are also clobbered here * in addition, any special features (such as rewriting * exclusive or) are easily handled here as well */ NODE * clocal(NODE *p) { register struct symtab *q; register NODE *r, *l; register int o; TWORD t; #ifdef PCC_DEBUG if (xdebug) { printf("clocal: %p\n", p); fwalk(p, eprint, 0); } #endif switch( o = p->n_op ){ case NAME: if ((q = p->n_sp) == NULL) return p; /* Nothing to care about */ switch (q->sclass) { case PARAM: case AUTO: /* fake up a structure reference */ r = block(REG, NIL, NIL, PTR+STRTY, 0, 0); slval(r, 0); r->n_rval = FPREG; p = stref(block(STREF, r, p, 0, 0, 0)); break; case REGISTER: p->n_op = REG; slval(p, 0); p->n_rval = q->soffset; break; case USTATIC: case STATIC: if (kflag == 0) break; if (blevel > 0 && !statinit) p = picstatic(p); break; case EXTERN: case EXTDEF: if (kflag == 0) break; if (blevel > 0 && !statinit) p = picext(p); break; } break; case ADDROF: if (kflag == 0 || blevel == 0 || statinit) break; /* char arrays may end up here */ l = p->n_left; if (l->n_op != NAME || (l->n_type != ARY+CHAR && l->n_type != ARY+WCHAR_TYPE)) break; l = p; p = picstatic(p->n_left); nfree(l); if (p->n_op != UMUL) cerror("ADDROF error"); l = p; p = p->n_left; nfree(l); break; case STASG: /* convert struct assignment to call memcpy */ l = p->n_left; if (l->n_op == NAME && ISFTN(l->n_sp->stype)) break; /* struct return, do nothing */ /* first construct arg list */ p->n_left = buildtree(ADDROF, p->n_left, 0); r = bcon(tsize(STRTY, p->n_df, p->n_ap)/SZCHAR); p->n_left = buildtree(CM, p->n_left, p->n_right); p->n_right = r; p->n_op = CM; p->n_type = INT; r = block(NAME, NIL, NIL, INT, 0, 0); r->n_sp = lookup(addname("memcpy"), SNORMAL); if (r->n_sp->sclass == SNULL) { r->n_sp->sclass = EXTERN; r->n_sp->stype = INCREF(VOID+PTR)+(FTN-PTR); } r->n_type = r->n_sp->stype; p = buildtree(CALL, r, p); break; case SCONV: l = p->n_left; if (l->n_op == ICON && ISPTR(l->n_type)) { /* Do immediate cast here */ /* Should be common code */ q = l->n_sp; l->n_sp = NULL; l->n_type = UNSIGNED; if (concast(l, p->n_type) == 0) cerror("clocal"); p = nfree(p); p->n_sp = q; } break; case FORCE: /* put return value in return reg */ p->n_op = ASSIGN; p->n_right = p->n_left; p->n_left = block(REG, NIL, NIL, p->n_type, 0, 0); t = p->n_type; if (ISITY(t)) t = t - (FIMAG-FLOAT); p->n_left->n_rval = RETREG(t); break; } #ifdef PCC_DEBUG if (xdebug) { printf("clocal end: %p\n", p); fwalk(p, eprint, 0); } #endif return(p); }
RIFActionBlock RIFActionBlock::parse(DPtr<uint8_t> *utf8str) throw(BadAllocException, SizeUnknownException, InvalidCodepointException, InvalidEncodingException, MalformedIRIRefException, TraceableException) { if (utf8str == NULL) { THROW(TraceableException, "utf8str must not be NULL."); } if (!utf8str->sizeKnown()) { THROWX(SizeUnknownException); } const uint8_t *begin = utf8str->dptr(); const uint8_t *end = begin + utf8str->size(); const uint8_t *mark = begin; for (; mark != end && is_space(*mark); ++mark) { // find beginning of action block } if (end - mark < 4) { THROW(TraceableException, "Could not find action block."); } if (ascii_strncmp(mark, "Do", 2) != 0) { THROW(TraceableException, "Action block must start with \"Do\"."); } mark += 2; for (; mark != end && is_space(*mark); ++mark) { // search for left parenthesis } if (mark == end || *mark != to_ascii('(')) { THROW(TraceableException, "Could not find opening parenthesis."); } for (--end; end != mark && is_space(*end); --end) { // find right parenthesis } if (end == mark || *end != to_ascii(')')) { THROW(TraceableException, "Could not find closing parenthesis."); } for (--end; end != mark && is_space(*end); --end) { // find end of last action } ++end; for (++mark; mark != end && is_space(*mark); ++mark) { // find first binding or action } if (mark == end) { THROW(TraceableException, "Action block is (illegaly) empty."); } deque<RIFAction> actions; ActVarMap bindings(RIFVar::cmplt0); bool find_bindings = (*mark == to_ascii('(')); const uint8_t *bound = mark; while (bound != end) { for (; bound != end && *bound != to_ascii(')'); ++bound) { // find end of action block binding or action... maybe } if (bound != end) { ++bound; } DPtr<uint8_t> *str = utf8str->sub(mark - begin, bound - mark); if (find_bindings) { try { RIFActVarBind bind = RIFActVarBind::parse(str); str->drop(); str = NULL; pair<ActVarMap::iterator, bool> p = bindings.insert( pair<RIFVar, RIFActVarBind>(bind.getActVar(), bind)); if (!p.second) { THROW(TraceableException, "Cannot have multiple bindings for same action variable."); } } catch (BadAllocException &e) { str->drop(); RETHROW(e, "Cannot parse action variable binding."); } catch (InvalidCodepointException &e) { str->drop(); RETHROW(e, "Cannot parse action variable binding."); } catch (InvalidEncodingException &e) { str->drop(); RETHROW(e, "Cannot parse action variable binding."); } catch (MalformedIRIRefException &e) { str->drop(); continue; } catch (TraceableException &e) { if (str == NULL) { RETHROW(e, "Malformed action block."); } str->drop(); continue; } } else { try { RIFAction act = RIFAction::parse(str); str->drop(); actions.push_back(act); } catch (BadAllocException &e) { str->drop(); RETHROW(e, "Cannot parse action."); } catch (InvalidCodepointException &e) { str->drop(); RETHROW(e, "Cannot parse action."); } catch (InvalidEncodingException &e) { str->drop(); RETHROW(e, "Cannot parse action."); } catch (MalformedIRIRefException &e) { str->drop(); continue; } catch (TraceableException &e) { str->drop(); continue; } } for (mark = bound; mark != end && is_space(*mark); ++mark) { // find beginning of next action block binding or action... maybe } bound = mark; find_bindings = find_bindings && (*mark == to_ascii('(')); } DPtr<RIFAction> *pact; try { NEW(pact, APtr<RIFAction>, actions.size()); } RETHROW_BAD_ALLOC copy(actions.begin(), actions.end(), pact->dptr()); try { RIFActionBlock block(pact, bindings); pact->drop(); return block; } catch (TraceableException &e) { pact->drop(); RETHROW(e, "Cannot parse action block."); } }
double CachedQuarkletProblem<PROBLEM>::a(const Index& lambda, const Index& nu) const { //const int lambda_num = number(lambda,2); double r = 0; WaveletBasis mybasis(basis()); const int jmax = mybasis.get_jmax_(); const int pmax = mybasis.get_pmax_(); const int lambda_num = number(lambda, jmax); const int nu_num = number(nu,jmax); //cout << "Punkt 1" << endl; // BE CAREFUL: KEY OF GENERATOR LEVEL IS j0-1 NOT j0 !!!! typedef typename Index::type_type generator_type; int j = (lambda.e() == generator_type()) ? (lambda.j()-1) : lambda.j(); // check wether entry has already been computed typedef std::list<Index> IntersectingList; // search for column 'nu' typename ColumnCache::iterator col_lb(entries_cache.lower_bound(nu_num)); typename ColumnCache::iterator col_it(col_lb); if (col_lb == entries_cache.end() || entries_cache.key_comp()(nu_num, col_lb->first)) { // insert a new column typedef typename ColumnCache::value_type value_type; col_it = entries_cache.insert(col_lb, value_type(nu_num, Column())); } //cout << "Punkt 2" << endl; Column& col(col_it->second); // check wether the level 'lambda' belongs to has already been calculated typename Column::iterator lb(col.lower_bound(j)); typename Column::iterator it(lb); // no entries have ever been computed for this column and this level if (lb == col.end() || col.key_comp()(j, lb->first)) { //cout << "Punkt 3" << endl; // compute whole level block // #### ONLY CDD COMPRESSION STRATEGY IMPLEMENTED #### // #### MAYBE WE ADD TRUNK FOR STEVENSON APPROACH #### // #### LATER. #### // insert a new level typedef typename Column::value_type value_type; it = col.insert(lb, value_type(j, Block())); Block& block(it->second); IntersectingList nus; for(int p=0; p<=pmax; p++){ intersecting_wavelets(basis(), nu, std::max(j, basis().j0()), j == (basis().j0()-1), nus, p); // for (typename IntersectingList::const_iterator it100(nus.begin()), itend(nus.end()); // it100 != itend; ++it100) { // cout << *it100 << endl; // } // compute entries for (typename IntersectingList::const_iterator it(nus.begin()), itend(nus.end()); it != itend; ++it) { const double entry = problem->a(*it, nu); // cout << *it << ", " << nu << ": " << entry << endl; // cout << (*it).number()+(*it).p()*waveletsonplevel << endl; typedef typename Block::value_type value_type_block; if (entry != 0.) { block.insert(block.end(), value_type_block(number(*it,jmax), entry)); if (number(*it,jmax) == lambda_num) { r = entry; } } } } //cout << "nu" << nu << endl; //cout << block.end() << endl; } // level already exists --> extract row corresponding to 'lambda' else { //cout << "ja" << endl; Block& block(it->second); //typename Block::iterator block_lb(block.lower_bound(lambda)); typename Block::iterator block_lb(block.lower_bound(lambda_num)); typename Block::iterator block_it(block_lb); // level exists, but in row 'lambda' no entry is available ==> entry must be zero if (block_lb == block.end() || block.key_comp()(lambda_num, block_lb->first)) { r = 0; } else { r = block_it->second; } } return r; }
void V8LazyEventListener::prepareListenerObject(ExecutionContext* executionContext) { if (!executionContext) return; // A ScriptState used by the event listener needs to be calculated based on // the ExecutionContext that fired the the event listener and the world // that installed the event listener. v8::HandleScope handleScope(toIsolate(executionContext)); v8::Local<v8::Context> v8Context = toV8Context(executionContext, world()); if (v8Context.IsEmpty()) return; ScriptState* scriptState = ScriptState::from(v8Context); if (!scriptState->contextIsValid()) return; if (!executionContext->isDocument()) return; if (!toDocument(executionContext)->allowInlineEventHandlers(m_node, this, m_sourceURL, m_position.m_line)) { clearListenerObject(); return; } if (hasExistingListenerObject()) return; ScriptState::Scope scope(scriptState); // Nodes other than the document object, when executing inline event // handlers push document, form owner, and the target node on the scope chain. // We do this by using 'with' statement. // See fast/forms/form-action.html // fast/forms/selected-index-value.html // fast/overflow/onscroll-layer-self-destruct.html HTMLFormElement* formElement = 0; if (m_node && m_node->isHTMLElement()) formElement = toHTMLElement(m_node)->formOwner(); v8::Local<v8::Object> scopes[3]; scopes[2] = toObjectWrapper<Node>(m_node, scriptState); scopes[1] = toObjectWrapper<HTMLFormElement>(formElement, scriptState); scopes[0] = toObjectWrapper<Document>(m_node ? m_node->ownerDocument() : 0, scriptState); v8::Local<v8::String> parameterName = v8String(isolate(), m_eventParameterName); v8::ScriptOrigin origin( v8String(isolate(), m_sourceURL), v8::Integer::New(isolate(), m_position.m_line.zeroBasedInt()), v8::Integer::New(isolate(), m_position.m_column.zeroBasedInt()), v8::True(isolate()), v8::Local<v8::Integer>(), v8::True(isolate())); v8::ScriptCompiler::Source source(v8String(isolate(), m_code), origin); v8::Local<v8::Function> wrappedFunction; { // JavaScript compilation error shouldn't be reported as a runtime // exception because we're not running any program code. Instead, // it should be reported as an ErrorEvent. v8::TryCatch block(isolate()); wrappedFunction = v8::ScriptCompiler::CompileFunctionInContext(isolate(), &source, v8Context, 1, ¶meterName, 3, scopes); if (block.HasCaught()) { fireErrorEvent(v8Context, executionContext, block.Message()); return; } } // Change the toString function on the wrapper function to avoid it // returning the source for the actual wrapper function. Instead it // returns source for a clean wrapper function with the event // argument wrapping the event source code. The reason for this is // that some web sites use toString on event functions and eval the // source returned (sometimes a RegExp is applied as well) for some // other use. That fails miserably if the actual wrapper source is // returned. v8::Local<v8::Function> toStringFunction = v8::Function::New(isolate(), V8LazyEventListenerToString); if (toStringFunction.IsEmpty()) return; String toStringString = "function " + m_functionName + "(" + m_eventParameterName + ") {\n " + m_code + "\n}"; V8HiddenValue::setHiddenValue(scriptState, wrappedFunction, V8HiddenValue::toStringString(isolate()), v8String(isolate(), toStringString)); if (!v8CallBoolean(wrappedFunction->Set(scriptState->context(), v8AtomicString(isolate(), "toString"), toStringFunction))) return; wrappedFunction->SetName(v8String(isolate(), m_functionName)); // FIXME: Remove the following comment-outs. // See https://bugs.webkit.org/show_bug.cgi?id=85152 for more details. // // For the time being, we comment out the following code since the // second parsing can happen. // // Since we only parse once, there's no need to keep data used for parsing around anymore. // m_functionName = String(); // m_code = String(); // m_eventParameterName = String(); // m_sourceURL = String(); setListenerObject(wrappedFunction, scriptState); }
int MPI_Type_create_darray(int size, int rank, int ndims, int gsize_array[], int distrib_array[], int darg_array[], int psize_array[], int order, MPI_Datatype oldtype, MPI_Datatype *newtype) { ompi_datatype_t *lastType; ptrdiff_t orig_extent, *st_offsets = NULL; int i, start_loop, end_loop, step; int *coords = NULL, rc = OMPI_SUCCESS; if (MPI_PARAM_CHECK) { int prod_psize = 1; OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if( (rank < 0) || (size < 0) || (rank >= size) ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } else if( ndims < 0 ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COUNT, FUNC_NAME); } else if( (NULL == gsize_array) || (NULL == distrib_array) || (NULL == darg_array) || (NULL == psize_array)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } else if (NULL == newtype) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_TYPE, FUNC_NAME); } else if( !(DT_FLAG_DATA & oldtype ->flags) ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_TYPE, FUNC_NAME); } else if( (MPI_ORDER_C != order) && (MPI_ORDER_FORTRAN != order) ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } for( i = 0; i < ndims; i++ ) { if( (MPI_DISTRIBUTE_BLOCK != distrib_array[i]) && (MPI_DISTRIBUTE_CYCLIC != distrib_array[i]) && (MPI_DISTRIBUTE_NONE != distrib_array[i]) ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } else if( (gsize_array[i] < 1) || (psize_array[i] < 0) || ((darg_array[i] < 0) && (MPI_DISTRIBUTE_DFLT_DARG != darg_array[i]) ) ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } else if( (MPI_DISTRIBUTE_DFLT_DARG != darg_array[i]) && (MPI_DISTRIBUTE_BLOCK == distrib_array[i]) && ((darg_array[i] * psize_array[i]) < gsize_array[i]) ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } else if( 1 > psize_array[i] ) return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); prod_psize *= psize_array[i]; } if( prod_psize != size ) return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } /* speedy corner case */ if (ndims < 1) { /* Don't just return MPI_DATATYPE_NULL as that can't be MPI_TYPE_FREE()ed, and that seems bad */ *newtype = ompi_ddt_create(0); ompi_ddt_add(*newtype, &ompi_mpi_datatype_null, 0, 0, 0); return MPI_SUCCESS; } rc = ompi_ddt_type_extent(oldtype, &orig_extent); if (MPI_SUCCESS != rc) goto cleanup; /* calculate position in grid using row-major ordering */ { int tmp_rank = rank, procs = size; coords = (int *) malloc(ndims * sizeof(int)); for (i = 0 ; i < ndims ; i++) { procs = procs / psize_array[i]; coords[i] = tmp_rank / procs; tmp_rank = tmp_rank % procs; } } st_offsets = (ptrdiff_t *) malloc(ndims * sizeof(ptrdiff_t)); /* duplicate type to here to 1) deal with constness without casting and 2) eliminate need to for conditional destroy below. Lame, yes. But cleaner code all around. */ rc = ompi_ddt_duplicate(oldtype, &lastType); if (OMPI_SUCCESS != rc) goto cleanup; /* figure out ordering issues */ if (MPI_ORDER_C == order) { start_loop = ndims - 1 ; step = -1; end_loop = -1; } else { start_loop = 0 ; step = 1; end_loop = ndims; } /* Build up array */ for (i = start_loop ; i != end_loop; i += step) { int nprocs, rank; switch(distrib_array[i]) { case MPI_DISTRIBUTE_BLOCK: rc = block(gsize_array, i, ndims, psize_array[i], coords[i], darg_array[i], order, orig_extent, lastType, newtype, st_offsets+i); break; case MPI_DISTRIBUTE_CYCLIC: rc = cyclic(gsize_array, i, ndims, psize_array[i], coords[i], darg_array[i], order, orig_extent, lastType, newtype, st_offsets+i); break; case MPI_DISTRIBUTE_NONE: /* treat it as a block distribution on 1 process */ if (order == MPI_ORDER_C) { nprocs = psize_array[i]; rank = coords[i]; } else { nprocs = 1; rank = 0; } rc = block(gsize_array, i, ndims, nprocs, rank, MPI_DISTRIBUTE_DFLT_DARG, order, orig_extent, lastType, newtype, st_offsets+i); break; default: rc = MPI_ERR_ARG; } ompi_ddt_destroy(&lastType); /* need to destroy the old type even in error condition, so don't check return code from above until after cleanup. */ if (MPI_SUCCESS != rc) goto cleanup; lastType = *newtype; } /* set displacement and UB correctly. Use struct instead of resized for same reason as subarray */ { ptrdiff_t displs[3]; ompi_datatype_t *types[3]; int tmp_size, blength[3] = { 1, 1, 1}; displs[1] = st_offsets[start_loop]; tmp_size = 1; for (i = start_loop + step ; i != end_loop ; i += step) { tmp_size *= gsize_array[i - step]; displs[1] += tmp_size * st_offsets[i]; } displs[0] = 0; displs[1] *= orig_extent; displs[2] = orig_extent; for (i = 0 ; i < ndims ; i++) { displs[2] *= gsize_array[i]; } types[0] = MPI_LB; types[1] = lastType; types[2] = MPI_UB; rc = ompi_ddt_create_struct(3, blength, displs, types, newtype); ompi_ddt_destroy(&lastType); /* need to destroy the old type even in error condition, so don't check return code from above until after cleanup. */ if (MPI_SUCCESS != rc) goto cleanup; } { int* a_i[8]; a_i[0] = &size; a_i[1] = &rank; a_i[2] = &ndims; a_i[3] = gsize_array; a_i[4] = distrib_array; a_i[5] = darg_array; a_i[6] = psize_array; a_i[7] = ℴ ompi_ddt_set_args( *newtype, 4 * ndims + 4, a_i, 0, NULL, 1, &oldtype, MPI_COMBINER_DARRAY ); } cleanup: if (NULL != st_offsets) free(st_offsets); if (NULL != coords) free(coords); OMPI_ERRHANDLER_RETURN(rc, MPI_COMM_WORLD, rc, FUNC_NAME); }
int QTextDocumentPrivate::undoRedo(bool undo) { PMDEBUG("%s, undoState=%d, undoStack size=%d", undo ? "undo:" : "redo:", undoState, undoStack.size()); if (!undoEnabled || (undo && undoState == 0) || (!undo && undoState == undoStack.size())) return -1; undoEnabled = false; beginEditBlock(); while (1) { if (undo) --undoState; QTextUndoCommand &c = undoStack[undoState]; int resetBlockRevision = c.pos; switch(c.command) { case QTextUndoCommand::Inserted: remove(c.pos, c.length, (QTextUndoCommand::Operation)c.operation); PMDEBUG(" erase: from %d, length %d", c.pos, c.length); c.command = QTextUndoCommand::Removed; break; case QTextUndoCommand::Removed: PMDEBUG(" insert: format %d (from %d, length %d, strpos=%d)", c.format, c.pos, c.length, c.strPos); insert_string(c.pos, c.strPos, c.length, c.format, (QTextUndoCommand::Operation)c.operation); c.command = QTextUndoCommand::Inserted; break; case QTextUndoCommand::BlockInserted: case QTextUndoCommand::BlockAdded: remove_block(c.pos, &c.blockFormat, c.command, (QTextUndoCommand::Operation)c.operation); PMDEBUG(" blockremove: from %d", c.pos); if (c.command == QTextUndoCommand::BlockInserted) c.command = QTextUndoCommand::BlockRemoved; else c.command = QTextUndoCommand::BlockDeleted; break; case QTextUndoCommand::BlockRemoved: case QTextUndoCommand::BlockDeleted: PMDEBUG(" blockinsert: charformat %d blockformat %d (pos %d, strpos=%d)", c.format, c.blockFormat, c.pos, c.strPos); insert_block(c.pos, c.strPos, c.format, c.blockFormat, (QTextUndoCommand::Operation)c.operation, c.command); resetBlockRevision += 1; if (c.command == QTextUndoCommand::BlockRemoved) c.command = QTextUndoCommand::BlockInserted; else c.command = QTextUndoCommand::BlockAdded; break; case QTextUndoCommand::CharFormatChanged: { resetBlockRevision = -1; // ## TODO PMDEBUG(" charFormat: format %d (from %d, length %d)", c.format, c.pos, c.length); FragmentIterator it = find(c.pos); Q_ASSERT(!it.atEnd()); int oldFormat = it.value()->format; setCharFormat(c.pos, c.length, formats.charFormat(c.format)); c.format = oldFormat; break; } case QTextUndoCommand::BlockFormatChanged: { resetBlockRevision = -1; // ## TODO PMDEBUG(" blockformat: format %d pos %d", c.format, c.pos); QTextBlock it = blocksFind(c.pos); Q_ASSERT(it.isValid()); int oldFormat = block(it)->format; block(it)->format = c.format; QTextBlockGroup *oldGroup = qobject_cast<QTextBlockGroup *>(objectForFormat(formats.blockFormat(oldFormat))); QTextBlockGroup *group = qobject_cast<QTextBlockGroup *>(objectForFormat(formats.blockFormat(c.format))); c.format = oldFormat; if (group != oldGroup) { if (oldGroup) oldGroup->blockRemoved(it); if (group) group->blockInserted(it); } else if (group) { group->blockFormatChanged(it); } documentChange(it.position(), it.length()); break; } case QTextUndoCommand::GroupFormatChange: { resetBlockRevision = -1; // ## TODO PMDEBUG(" group format change"); QTextObject *object = objectForIndex(c.objectIndex); int oldFormat = formats.objectFormatIndex(c.objectIndex); changeObjectFormat(object, c.format); c.format = oldFormat; break; } case QTextUndoCommand::Custom: resetBlockRevision = -1; // ## TODO if (undo) c.custom->undo(); else c.custom->redo(); break; default: Q_ASSERT(false); } if (resetBlockRevision >= 0) { int b = blocks.findNode(resetBlockRevision); QTextBlockData *B = blocks.fragment(b); B->revision = c.revision; } if (undo) { if (undoState == 0 || !undoStack[undoState-1].block) break; } else { ++undoState; if (undoState == undoStack.size() || !undoStack[undoState-1].block) break; } } undoEnabled = true; int editPos = -1; if (docChangeFrom >= 0) { editPos = qMin(docChangeFrom + docChangeLength, length() - 1); } endEditBlock(); emitUndoAvailable(isUndoAvailable()); emitRedoAvailable(isRedoAvailable()); return editPos; }
/** * Compute a path from (x1,y1) to (x2,y2) * Store waypoint inside path * limit is the maximum number of explored node * @return true if a path is found */ bool MapCollision::compute_path(FPoint start_pos, FPoint end_pos, std::vector<FPoint> &path, MOVEMENTTYPE movement_type, unsigned int limit) { if (is_outside_map(end_pos.x, end_pos.y)) return false; if (limit == 0) limit = std::max(map_size.x, map_size.y); // path must be empty if (!path.empty()) path.clear(); // convert start & end to MapCollision precision Point start = map_to_collision(start_pos); Point end = map_to_collision(end_pos); // if the target square has an entity, temporarily clear it to compute the path bool target_blocks = false; int target_blocks_type = colmap[end.x][end.y]; if (colmap[end.x][end.y] == BLOCKS_ENTITIES || colmap[end.x][end.y] == BLOCKS_ENEMIES) { target_blocks = true; unblock(end_pos.x, end_pos.y); } Point current = start; AStarNode* node = new AStarNode(start); node->setActualCost(0); node->setEstimatedCost(static_cast<float>(calcDist(start,end))); node->setParent(current); AStarContainer open(map_size.x, map_size.y, limit); AStarCloseContainer close(map_size.x, map_size.y, limit); open.add(node); while (!open.isEmpty() && static_cast<unsigned>(close.getSize()) < limit) { node = open.get_shortest_f(); current.x = node->getX(); current.y = node->getY(); close.add(node); open.remove(node); if ( current.x == end.x && current.y == end.y) break; //path found ! //limit evaluated nodes to the size of the map std::list<Point> neighbours = node->getNeighbours(map_size.x, map_size.y); // for every neighbour of current node for (std::list<Point>::iterator it=neighbours.begin(); it != neighbours.end(); ++it) { Point neighbour = *it; // do not exceed the node limit when adding nodes if (static_cast<unsigned>(open.getSize()) >= limit) { break; } // if neighbour is not free of any collision, skip it if (!is_valid_tile(neighbour.x,neighbour.y,movement_type, false)) continue; // if nabour is already in close, skip it if(close.exists(neighbour)) continue; // if neighbour isn't inside open, add it as a new Node if(!open.exists(neighbour)) { AStarNode* newNode = new AStarNode(neighbour.x,neighbour.y); newNode->setActualCost(node->getActualCost() + static_cast<float>(calcDist(current,neighbour))); newNode->setParent(current); newNode->setEstimatedCost(static_cast<float>(calcDist(neighbour,end))); open.add(newNode); } // else, update it's cost if better else { AStarNode* i = open.get(neighbour.x, neighbour.y); if (node->getActualCost() + static_cast<float>(calcDist(current,neighbour)) < i->getActualCost()) { Point pos(i->getX(), i->getY()); Point parent_pos(node->getX(), node->getY()); open.updateParent(pos, parent_pos, node->getActualCost() + static_cast<float>(calcDist(current,neighbour))); } } } } if (current.x != end.x || current.y != end.y) { //couldnt find the target so map a path to the closest node found node = close.get_shortest_h(); current.x = node->getX(); current.y = node->getY(); while (current.x != start.x || current.y != start.y) { path.push_back(collision_to_map(current)); current = close.get(current.x, current.y)->getParent(); } } else { // store path from end to start path.push_back(collision_to_map(end)); while (current.x != start.x || current.y != start.y) { path.push_back(collision_to_map(current)); current = close.get(current.x, current.y)->getParent(); } } // reblock target if needed if (target_blocks) block(end_pos.x, end_pos.y, target_blocks_type == BLOCKS_ENEMIES); return !path.empty(); }
CConfigHelper* CConfigHelper::getInstance(const IPropertyTree *cfg, const char* esp_name, IDeploymentCallback *pCallBack) { CriticalBlock block(m_critSect); static CConfigHelper *p_sConfigHelper = NULL; StringBuffer xpath1, xpath2; if (p_sConfigHelper != NULL) { return p_sConfigHelper; } p_sConfigHelper = new CConfigHelper(pCallBack); if (cfg != NULL && esp_name != NULL) { xpath1.clear().appendf("%s/%s/%s[%s='%s']/%s",XML_TAG_SOFTWARE, XML_TAG_ESPPROCESS, XML_TAG_ESPSERVICE, XML_ATTR_NAME, esp_name, XML_TAG_LOCALCONFFILE); p_sConfigHelper->m_strConfFile = cfg->queryProp(xpath1.str()); xpath2.clear().appendf("%s/%s/%s[%s='%s']/%s",XML_TAG_SOFTWARE, XML_TAG_ESPPROCESS, XML_TAG_ESPSERVICE, XML_ATTR_NAME, esp_name, XML_TAG_LOCALENVCONFFILE); p_sConfigHelper->m_strEnvConfFile = cfg->queryProp(xpath2.str()); if (p_sConfigHelper->m_strConfFile.length() > 0 && p_sConfigHelper->m_strEnvConfFile.length() > 0 && checkFileExists(p_sConfigHelper->m_strConfFile.str()) && checkFileExists(p_sConfigHelper->m_strEnvConfFile.str())) { Owned<IProperties> pParams = createProperties(p_sConfigHelper->m_strConfFile.str()); Owned<IProperties> pEnvParams = createProperties(p_sConfigHelper->m_strEnvConfFile.str()); p_sConfigHelper->m_strConfigXMLDir = pEnvParams->queryProp(TAG_PATH); if (p_sConfigHelper->m_strConfigXMLDir.length() == 0) { p_sConfigHelper->m_strConfigXMLDir = INSTALL_DIR; } p_sConfigHelper->m_strBuildSetFileName = pParams->queryProp(TAG_BUILDSET); p_sConfigHelper->m_strBuildSetFilePath.append(p_sConfigHelper->m_strConfigXMLDir).append(STANDARD_CONFIG_CONFIGXML_DIR).append( p_sConfigHelper->m_strBuildSetFileName.length() > 0 ? p_sConfigHelper->m_strBuildSetFileName : STANDARD_CONFIG_BUILDSETFILE); try { p_sConfigHelper->m_pDefBldSet.set(createPTreeFromXMLFile(p_sConfigHelper->m_strBuildSetFilePath.str())); } catch (IException *e) { if (p_sConfigHelper->m_pDefBldSet.get() != NULL) { p_sConfigHelper->m_pDefBldSet.clear(); } StringBuffer msg; e->errorMessage(msg); delete e; if (p_sConfigHelper->m_cbDeployment.get() != NULL) { p_sConfigHelper->m_cbDeployment->printStatus(STATUS_ERROR, NULL, NULL, NULL, "Failed create PTree from buildset.xml file %s with error %s", p_sConfigHelper->m_strBuildSetFilePath.str(), msg.str()); return p_sConfigHelper; } else { throw MakeStringException(-1, "Failed create PTree from buildset.xml file %s with error %s", p_sConfigHelper->m_strBuildSetFilePath.str(), msg.str()); } } try { p_sConfigHelper->appendBuildSetFromPlugins(); } catch (IException *e) { if (p_sConfigHelper->m_cbDeployment.get() != NULL) { StringBuffer msg; e->errorMessage(msg); p_sConfigHelper->m_cbDeployment->printStatus(STATUS_ERROR, NULL, NULL, NULL, "Failed to add plugin buildset.xml file %s with error %s", p_sConfigHelper->m_strBuildSetFilePath.str(), msg.str()); } // TODO: log message to configmgr log but continue execution delete e; } return p_sConfigHelper; } else { delete p_sConfigHelper; p_sConfigHelper = NULL; throw MakeStringException(-1, "Config file does not define values for %s and %s", xpath1.str(), xpath2.str()); } } return p_sConfigHelper; }
/* setup a 64-bit parameter (double/ldouble/longlong) * used by bfcode() */ static void param_64bit(struct symtab *sym, int *argofsp, int dotemps) { int argofs = *argofsp; NODE *p, *q; int navail; #if ALLONGLONG == 64 /* alignment */ ++argofs; argofs &= ~1; *argofsp = argofs; #endif navail = NARGREGS - argofs; if (navail < 2) { /* half in and half out of the registers */ if (features(FEATURE_BIGENDIAN)) { cerror("param_64bit"); p = q = NULL; } else { q = block(REG, NIL, NIL, INT, 0, 0); regno(q) = R0 + argofs; if (dotemps) { q = block(SCONV, q, NIL, ULONGLONG, 0, 0); p = nametree(sym); p->n_type = ULONGLONG; p->n_df = 0; p->n_ap = NULL; p = block(LS, p, bcon(32), ULONGLONG, 0, 0); q = block(PLUS, p, q, ULONGLONG, 0, 0); p = tempnode(0, ULONGLONG, 0, 0); sym->soffset = regno(p); sym->sflags |= STNODE; } else { p = nametree(sym); regno(p) = sym->soffset; p->n_type = INT; p->n_df = 0; p->n_ap = NULL; } } p = buildtree(ASSIGN, p, q); ecomp(p); *argofsp = argofs + 2; return; } q = block(REG, NIL, NIL, sym->stype, sym->sdf, sym->sap); regno(q) = R0R1 + argofs; if (dotemps) { p = tempnode(0, sym->stype, sym->sdf, sym->sap); sym->soffset = regno(p); sym->sflags |= STNODE; } else { p = nametree(sym); } p = buildtree(ASSIGN, p, q); ecomp(p); *argofsp = argofs + 2; }
void fullmoonfever(void) { int ok = 1; while(ok) { if(tokeq("ILLGOL") || tokeq("Illgola2") || tokeq("Illberon") || tokeq("Illgol##")) { scan(); block(); } else if(tokeq("GO")) { scan(); boolexpr(); boolexpr(); g_pop_ax(); g_pop_dx(); g_mov_dh_al(); g_mov_ah(2); g_xor_bx_bx(); g_int(0x10); } else if(tokeq("PRINT")) { scan(); boolexpr(); g_mov_ah(0x0e); g_pop_si(); g_label(); g_mov_al_SI(); g_or_al_al(); g_jz(12); g_mov_bx_I(caddr(pencolor)); g_xor_bh_bh(); g_int(16); g_inc_si(); g_jmp(-18); g_label(); } else if(tokeq("CENTRE")) { int l = 0; scan(); l = (80-(strlen(token)-1)) >> 1; boolexpr(); boolexpr(); g_pop_ax(); g_mov_dx(l); g_mov_dh_al(); g_mov_ah(2); g_xor_bx_bx(); g_int(0x10); g_mov_ah(0x0e); g_pop_si(); g_label(); g_mov_al_SI(); g_or_al_al(); g_jz(12); g_mov_bx_I(caddr(pencolor)); g_xor_bh_bh(); g_int(16); g_inc_si(); g_jmp(-18); g_label(); } else if(tokeq("PAUSE"))
/* called from moveargs() */ static NODE * movearg_struct(NODE *p, int *regp) { int reg = *regp; NODE *l, *q, *t, *r; int tmpnr; int navail; int num; int sz; int ty; int i; assert(p->n_op == STARG); navail = NARGREGS - (reg - R0); navail = navail < 0 ? 0 : navail; sz = tsize(p->n_type, p->n_df, p->n_ap) / SZINT; num = sz > navail ? navail : sz; /* remove STARG node */ l = p->n_left; nfree(p); ty = l->n_type; /* * put it into a TEMP, rather than tcopy(), since the tree * in p may have side-affects */ t = tempnode(0, ty, l->n_df, l->n_ap); tmpnr = regno(t); q = buildtree(ASSIGN, t, l); /* copy structure into registers */ for (i = 0; i < num; i++) { t = tempnode(tmpnr, ty, 0, 0); t = block(SCONV, t, NIL, PTR+INT, 0, 0); t = block(PLUS, t, bcon(4*i), PTR+INT, 0, 0); t = buildtree(UMUL, t, NIL); r = block(REG, NIL, NIL, INT, 0, 0); regno(r) = reg++; r = buildtree(ASSIGN, r, t); q = block(CM, q, r, INT, 0, 0); } /* put the rest of the structure on the stack */ for (i = num; i < sz; i++) { t = tempnode(tmpnr, ty, 0, 0); t = block(SCONV, t, NIL, PTR+INT, 0, 0); t = block(PLUS, t, bcon(4*i), PTR+INT, 0, 0); t = buildtree(UMUL, t, NIL); r = pusharg(t, ®); q = block(CM, q, r, INT, 0, 0); } q = reverse(q); *regp = reg; return q; }
/* Get the computer's move */ void get_computer_move(void) { check=0; block(); if(check==0) { if (count==1) ip=2; else if(count==3) { if(t[1]=='O' || t[3]=='O' || t[5]=='O' || t[8]=='O') ip=9; else if(t[4]=='O' || t[6]=='O') ip=5; else if(t[7]=='O') ip=1; else if(t[9]=='O') ip=3; } else if(count==5) { switch(readip) { case 7: if(t[1]=='O') ip=5; else if(t[3]=='O') ip=5; else if(t[5]=='O') ip=3; else if(t[8]=='O') ip=3; else do { ip=random(10); }while(ip==0); break; case 8: if(t[4]=='O' || t[6]=='O') ip=3; else do { ip=random(10); }while(ip==0); break; case 3: if(t[7]=='O') ip=5; else if(t[1]=='O') ip=8; else do { ip=random(10); }while(ip==0); break; case 1: ip=5; break; case 4: if(t[8]=='O') ip=3; else do { ip=random(10); }while(ip==0); break; case 5: if(t[8]=='O') ip=3; else do { ip=random(10); }while(ip==0); break; case 6: if(t[8]=='O') ip=1; else do { ip=random(10); }while(ip==0); break; default:do { ip=random(10); }while(ip==0); break; } } else if (count==7) { do { ip=random(10); } while(ip==0); } else if(count==9) { for (int i=1;i<=9;i++) { itoa(i,ic,10); if(t[i]==ic[0]) { ip=i; break; } } } } itoa(ip,c,10); for (int i=1; i<=10; i++) //Dis-allows duplicate entries { if (c[0]==b[i]) { get_computer_move(); } } }
/** Begin new block. */ Struct writeBlock(uint8_t type = InvalidType) { Struct block(mBuf, mBuf.size()); if(type != InvalidType) block.push(type); return block; }
int main(int argc, char** argv) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " <file name>\n"; return 1; } // Open a new file and write the EBML Header. This specifies that the file // is an EBML file, and is a Tawara document. std::fstream stream(argv[1], std::ios::in|std::ios::out|std::ios::trunc); tawara::EBMLElement ebml_el; ebml_el.write(stream); // Open a new segment in the file. This will write some initial meta-data // and place some padding at the start of the file for final meta-data to // be written after tracks, clusters, etc. have been written. tawara::Segment segment; segment.write(stream); // Set up the segment information so it can be used while writing tracks // and clusters. // A UID is not required, but is highly recommended. boost::uuids::random_generator gen; boost::uuids::uuid uuid = gen(); std::vector<char> uuid_data(uuid.size()); std::copy(uuid.begin(), uuid.end(), uuid_data.begin()); segment.info.uid(uuid_data); // The filename can be nice to know. segment.info.filename(argv[1]); // The segment's timecode scale is possibly the most important value in the // segment meta-data data. Without it, timely playback of frames is not // possible. It has a sensible default (defined in the Tawara specification), // but here we set it to ten milliseconds for demonstrative purposes. segment.info.timecode_scale(10000000); // The segment's date should be set. It is the somewhat-awkward value of // the number of seconds since the start of the millenium. Boost::Date_Time // to the rescue! bpt::ptime basis(boost::gregorian::date(2001, 1, 1)); bpt::ptime start(bpt::second_clock::local_time()); bpt::time_duration td = start - basis; segment.info.date(td.total_seconds()); // Let's give the segment an inspirational title. segment.info.title("Example segment"); // It sometimes helps to know what created a Tawara file. segment.info.muxing_app("libtawara-0.1"); segment.info.writing_app("tawara_eg_write"); // Set up the tracks meta-data and write it to the file. tawara::Tracks tracks; // Each track is represented in the Tracks information by a TrackEntry. // This specifies such things as the track number, the track's UID and the // codec used. tawara::TrackEntry::Ptr track(new tawara::TrackEntry(1, 1, "string")); track->name("Example frames"); track->codec_name("ASCII string"); // Adding each level 1 element (only the first occurance, in the case of // clusters) to the index makes opening the file later much faster. segment.index.insert(std::make_pair(tracks.id(), segment.to_segment_offset(stream.tellp()))); // Now we can write the Tracks element. tracks.insert(track); tracks.write(stream); // The data itself is stored in clusters. Each cluster contains a number of // blocks, with each block containing a single frame of data. Different // cluster implementations are available using different optimisations. // Here, we use the implementation that stores all its blocks in memory // before writing them all to the file at once. As with the segment, // clusters must be opened for writing before blocks are added. Once the // cluster is complete, it is finalised. How many blocks each cluster // contains is relatively flexible: the only limitation is on the range of // block timecodes that can be stored. Each timecode is a signed 16-bit // integer, and usually blocks have timecodes that are positive, limiting // the range to 32767. The unit of this value is the segment's timecode // scale. The default timecode scale therefore gives approximately 65 // seconds of total range, with 32 seconds being used. tawara::MemoryCluster cluster; // Again, we add the cluster to the index for faster file opening. segment.index.insert(std::make_pair(cluster.id(), segment.to_segment_offset(stream.tellp()))); // The cluster's timecode determines the basis for the timecodes of all // blocks in that cluster. bpt::ptime c_start(bpt::second_clock::local_time()); bpt::time_duration c_td = c_start - start; cluster.timecode(c_td.total_microseconds() / 10000); // Open the cluster for writing so we can begin adding blocks. cluster.write(stream); // Here, a few blocks are added. for (int ii(1); ii <= 5; ++ii) { std::string frame("frame 1"); frame[6] = ii + '0'; // When creating a block, the track number must be specified. In our // case, all blocks belong to track 1. A timecode must also be given. // It is an offset from the cluster's timecode measured in the // segment's timecode scale. bpt::ptime b_start(bpt::second_clock::local_time()); bpt::time_duration b_td = b_start - c_start; tawara::BlockElement::Ptr block(new tawara::SimpleBlock(1, b_td.total_microseconds() / 10000)); // Here the frame data itself is added to the block tawara::Block::FramePtr frame_ptr( new tawara::Block::Frame(frame.begin(), frame.end())); block->push_back(frame_ptr); // And then the block is added to its cluster. cluster.push_back(block); } // Finally, now that all blocks have been added, the cluster is finalised. cluster.finalise(stream); // Now we'll add another cluster, this time using the in-file cluster // implementation. tawara::FileCluster cluster2; // This cluster does not need to be added to the index, as it is easily // found during reading by skipping past the first cluster. // Give the cluster a timecode. c_start = bpt::second_clock::local_time(); c_td = c_start - start; cluster2.timecode(c_td.total_microseconds() / 10000); // Open the cluster for writing. cluster2.write(stream); // Add some blocks. for (int ii(0); ii < 10; ++ii) { std::string frame("frame a"); frame[6] = ii + 'a'; // The block's timecode bpt::ptime b_start(bpt::second_clock::local_time()); bpt::time_duration b_td = b_start - c_start; tawara::BlockElement::Ptr block(new tawara::SimpleBlock(1, b_td.total_microseconds() / 10000)); // Add the frame data to the block. tawara::Block::FramePtr frame_ptr( new tawara::Block::Frame(frame.begin(), frame.end())); block->push_back(frame_ptr); // Add the block to the cluster. cluster2.push_back(block); } // Finally, now that all blocks have been added, the cluster is finalised. cluster2.finalise(stream); // Now that all the data has been written, the last thing to do is to // finalise the segment. segment.finalise(stream); // And close the file. stream.close(); return 0; }