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

void fimg2d4x_set_src_image(struct fimg2d_control *info, struct fimg2d_image *s){	unsigned long cfg;	wr(FIMG2D_ADDR(s->addr.start), FIMG2D_SRC_BASE_ADDR_REG);	wr(FIMG2D_STRIDE(s->stride), FIMG2D_SRC_STRIDE_REG);	if (s->order < ARGB_ORDER_END) {	/* argb */		cfg = s->order << FIMG2D_RGB_ORDER_SHIFT;		if (s->fmt == CF_A8)			wr(a8_rgbcolor, FIMG2D_SRC_A8_RGB_EXT_REG);	} else if (s->order < P1_ORDER_END) {	/* YCbC1 1plane */		cfg = (s->order - P1_CRY1CBY0) << FIMG2D_YCBCR_ORDER_SHIFT;	} else {	/* YCbCr 2plane */		cfg = (s->order - P2_CRCB) << FIMG2D_YCBCR_ORDER_SHIFT;		cfg |= FIMG2D_YCBCR_2PLANE;		wr(FIMG2D_ADDR(s->plane2.start),				FIMG2D_SRC_PLANE2_BASE_ADDR_REG);	}	cfg |= s->fmt << FIMG2D_COLOR_FORMAT_SHIFT;	wr(cfg, FIMG2D_SRC_COLOR_MODE_REG);}

void dmtcp_ProcessInfo_ProcessEvent(DmtcpEvent_t event, DmtcpEventData_t *data){  switch (event) {    case DMTCP_EVENT_PRE_EXEC:      {        jalib::JBinarySerializeWriterRaw wr("", data->serializerInfo.fd);        dmtcp::ProcessInfo::instance().serialize(wr);      }      break;    case DMTCP_EVENT_POST_EXEC:      {        jalib::JBinarySerializeReaderRaw rd("", data->serializerInfo.fd);        dmtcp::ProcessInfo::instance().serialize(rd);        dmtcp::ProcessInfo::instance().postExec();      }      break;    case DMTCP_EVENT_WRITE_CKPT_PREFIX:      {        jalib::JBinarySerializeWriterRaw wr("", data->serializerInfo.fd);        dmtcp::ProcessInfo::instance().serialize(wr);      }      break;    default:      break;  }}

/** * @d: set base address, stride, color format, order */void fimg2d4x_set_dst_image(struct fimg2d_control *info, struct fimg2d_image *d){	unsigned long cfg;	wr(FIMG2D_ADDR(d->addr.start), FIMG2D_DST_BASE_ADDR_REG);	wr(FIMG2D_STRIDE(d->stride), FIMG2D_DST_STRIDE_REG);	if (d->order < ARGB_ORDER_END) {		cfg = d->order << FIMG2D_RGB_ORDER_SHIFT;		if (d->fmt == CF_A8)			wr(a8_rgbcolor, FIMG2D_DST_A8_RGB_EXT_REG);	} else if (d->order < P1_ORDER_END) {		cfg = (d->order - P1_CRY1CBY0) << FIMG2D_YCBCR_ORDER_SHIFT;	} else {		cfg = (d->order - P2_CRCB) << FIMG2D_YCBCR_ORDER_SHIFT;		cfg |= FIMG2D_YCBCR_2PLANE;		wr(FIMG2D_ADDR(d->plane2.start),				FIMG2D_DST_PLANE2_BASE_ADDR_REG);	}	cfg |= d->fmt << FIMG2D_COLOR_FORMAT_SHIFT;	wr(cfg, FIMG2D_DST_COLOR_MODE_REG);}

static int dib3000mb_tuner_pass_ctrl(struct dvb_frontend *fe, int onoff, u8 pll_addr){	struct dib3000_state *state = fe->demodulator_priv;	if (onoff) {		wr(DIB3000MB_REG_TUNER, DIB3000_TUNER_WRITE_ENABLE(pll_addr));	} else {		wr(DIB3000MB_REG_TUNER, DIB3000_TUNER_WRITE_DISABLE(pll_addr));	}	return 0;}

static voidmiiwr(Dev *d, int idx, int val){	while(rr(d, MIIaddr) & MIIbusy)		;	wr(d, MIIdata, val);	wr(d, MIIaddr, PHYinternal<<11 | idx<<6 | MIIwrite);	while(rr(d, MIIaddr) & MIIbusy)		;}

/** * If solid color fill is enabled, other blit command is ignored. * Color format of solid color is considered to be *	the same as destination color format * Channel order of solid color is A-R-G-B or Y-Cb-Cr */void fimg2d4x_set_color_fill(struct fimg2d_control *info, unsigned long color){	wr(FIMG2D_SOLID_FILL, FIMG2D_BITBLT_COMMAND_REG);	/* sf color */	wr(color, FIMG2D_SF_COLOR_REG);	/* set 16 burst for performance */	fimg2d4x_set_max_burst_length(info, MAX_BURST_16);}

static int dib3000mb_fifo_control(struct dvb_frontend *fe, int onoff){	struct dib3000_state *state = fe->demodulator_priv;	deb_xfer("%s fifo/n",onoff ? "enabling" : "disabling");	if (onoff) {		wr(DIB3000MB_REG_FIFO, DIB3000MB_FIFO_ACTIVATE);	} else {		wr(DIB3000MB_REG_FIFO, DIB3000MB_FIFO_INHIBIT);	}	return 0;}

void fimg2d4x_set_rotation(struct fimg2d_control *info, enum rotation rot){	int rev_rot90;	/* counter clockwise, 4.1 specific */	unsigned long cfg;	enum addressing dirx, diry;	rev_rot90 = 0;	dirx = diry = FORWARD_ADDRESSING;	switch (rot) {	case ROT_90:	/* -270 degree */		rev_rot90 = 1;	/* fall through */	case ROT_180:		dirx = REVERSE_ADDRESSING;		diry = REVERSE_ADDRESSING;		break;	case ROT_270:	/* -90 degree */		rev_rot90 = 1;		break;	case XFLIP:		diry = REVERSE_ADDRESSING;		break;	case YFLIP:		dirx = REVERSE_ADDRESSING;		break;	case ORIGIN:	default:		break;	}	/* destination direction */	if (dirx == REVERSE_ADDRESSING || diry == REVERSE_ADDRESSING) {		cfg = rd(FIMG2D_DST_PAT_DIRECT_REG);		if (dirx == REVERSE_ADDRESSING)			cfg |= FIMG2D_DST_X_DIR_NEGATIVE;		if (diry == REVERSE_ADDRESSING)			cfg |= FIMG2D_DST_Y_DIR_NEGATIVE;		wr(cfg, FIMG2D_DST_PAT_DIRECT_REG);	}	/* rotation -90 */	if (rev_rot90) {		cfg = rd(FIMG2D_ROTATE_REG);		cfg |= FIMG2D_SRC_ROTATE_90;		cfg |= FIMG2D_MSK_ROTATE_90;		wr(cfg, FIMG2D_ROTATE_REG);	}}

void wrAnimations(char* file, int animationlength){  wr(file,0x144,animationlength);  wr(file,0x14c,0x00000020);  wr(file,0x150,0x00007fff);  wr(file,0x160,0x7F7FFFFF);  wr(file,0x164,0x7F7FFFFF);  wr(file,0x168,0x7F7FFFFF);  wr(file,0x16c,0xFF7FFFFF);  wr(file,0x170,0xFF7FFFFF);  wr(file,0x174,0xFF7FFFFF);  wr(file,0x17c,0x0000FFFF);}

/** * @c: destination clipping region */void fimg2d4x_enable_clipping(struct fimg2d_control *info,				struct fimg2d_clip *clp){	unsigned long cfg;	cfg = rd(FIMG2D_BITBLT_COMMAND_REG);	cfg |= FIMG2D_ENABLE_CW;	wr(cfg, FIMG2D_BITBLT_COMMAND_REG);	wr(FIMG2D_OFFSET(clp->x1, clp->y1), FIMG2D_CW_LT_REG);	wr(FIMG2D_OFFSET(clp->x2, clp->y2), FIMG2D_CW_RB_REG);}

static void send(char buf,char len){  unsigned char i;  for(i = 0;i < len;i ++)  {    if(buf & 0x80)data(1);    else data(0);    wr(0);    delay();    wr(1);    delay();    buf <<= 1;  }}

voidofw_pci_dmamap_sync_stst_order_common(void){    static u_char buf[VIS_BLOCKSIZE] __aligned(VIS_BLOCKSIZE);    register_t reg, s;    s = intr_disable();    reg = rd(fprs);    wr(fprs, reg | FPRS_FEF, 0);    __asm __volatile("stda %%f0, [%0] %1"                     : : "r" (buf), "n" (ASI_BLK_COMMIT_S));    membar(Sync);    wr(fprs, reg, 0);    intr_restore(s);}

bool schur(const mat &A, mat &U, mat &T){  it_assert_debug(A.rows() == A.cols(), "schur(): Matrix is not square");  char jobvs = 'V';  char sort = 'N';  int info;  int n = A.rows();  int lda = n;  int ldvs = n;  int lwork = 3 * n; // This may be choosen better!  int sdim = 0;  vec wr(n);  vec wi(n);  vec work(lwork);  T.set_size(lda, n, false);  U.set_size(ldvs, n, false);  T = A; // The routine overwrites input matrix with eigenvectors  dgees_(&jobvs, &sort, 0, &n, T._data(), &lda, &sdim, wr._data(), wi._data(),         U._data(), &ldvs, work._data(), &lwork, 0, &info);  return (info == 0);}

static void paint_children(QWidget * p,const QRegion& r, bool post){    if(!p)	return;    QObjectList * childObjects=(QObjectList*)p->children();    if(childObjects) {	QObject * o;	for(o=childObjects->first();o!=0;o=childObjects->next()) {	    if( o->isWidgetType() ) {		QWidget *w = (QWidget *)o;		if ( w->testWState(Qt::WState_Visible) ) {		    QRegion wr( QRegion(w->geometry()) & r );		    if ( !wr.isEmpty() ) {			wr.translate(-w->x(),-w->y());			if ( post )			    QApplication::postEvent(w,new QPaintEvent(wr,				   !w->testWFlags(QWidget::WRepaintNoErase) ) );			else			    w->repaint(wr, !w->testWFlags(QWidget::WRepaintNoErase));			paint_children(w,wr,post);		    }		}	    }	}    }}

QPixmap QPixmap::grabWidget( QWidget * widget, int x, int y, int w, int h ){    QPixmap res;    if ( !widget )	return res;    if ( w < 0 )	w = widget->width() - x;    if ( h < 0 )	h = widget->height() - y;    QRect wr( x, y, w, h );    if ( wr == widget->rect() )	return grabChildWidgets( widget );    if ( !wr.intersects( widget->rect() ) )	return res;    res.resize( w, h );    if( res.isNull() )	return res;    res.fill( widget, QPoint( w,h ) );    QPixmap tmp( grabChildWidgets( widget ) );    if( tmp.isNull() )	return tmp;    ::bitBlt( &res, 0, 0, &tmp, x, y, w, h );    return res;}

QByteArray QUsbHid::readAll(){    QByteArray res = readBuffer;    QWriteLocker wr(readBufferLock);    readBuffer.clear();    return res;}

static int dib3000mb_pid_parse(struct dvb_frontend *fe, int onoff){	struct dib3000_state *state = fe->demodulator_priv;	deb_xfer("%s pid parsing/n",onoff ? "enabling" : "disabling");	wr(DIB3000MB_REG_PID_PARSE,onoff);	return 0;}

HRESULT CMyTrackPriceInfoWithNotify::OnLastQuote(CComVariant &varParams, CComVariant &varResults){	_QuoteUpdateParams params(varParams);	_QuoteUpdateInfo   results(varResults);	_bstr_t bsFullSymbol  = params->Symbol;	bsFullSymbol +=_T("_");	bsFullSymbol += params->Exchange;	if(params->Type == enOPT)		bsFullSymbol +=_T("_");	{		CCriticalSectionWrapper wr(m_csCache);		m_SymbolsCache[bsFullSymbol] = varResults;	}	CResponce resp;	resp.m_enType = CResponce::enLastQuote;	resp.m_bsFullSymbol = bsFullSymbol;	resp.m_vtRequest = varParams;	resp.m_vtResponce = varResults;	{		CCriticalSectionWrapper d(m_csResponce);		m_Responce.insert(m_Responce.end(), resp);			}	SetEvent(m_hResponce);	return S_OK;}

int mpx_test (int argc, const char **argv){  wr(10);  rd(10, -1);  return 0;}

static int dib3000mb_sleep(struct dvb_frontend* fe){	struct dib3000_state* state = fe->demodulator_priv;	deb_info("dib3000mb is going to bed./n");	wr(DIB3000MB_REG_POWER_CONTROL, DIB3000MB_POWER_DOWN);	return 0;}

string CubeDocBase::serializeMinBin(){    string ret;    BinWriter wr(ret);    wr.addBits(0x01, 8); // version    wr.addBits(m_shp->fcn, 8);    for (int i = 0; i < m_shp->fcn; ++i) {        const auto& face = m_shp->faces[i];        wr.addBits(face.ex.x / 4, 6);        wr.addBits(face.ex.y / 4, 6);        wr.addBits(face.ex.z / 4, 6);        wr.addBits(face.dr, 2);    }    auto slv = getCurrentSolve();    if (slv != nullptr)    {        M_ASSERT(slv->dt.size() == m_shp->fcn);        for (int i = 0; i < m_shp->fcn; ++i) {            wr.addBits(slv->dt[i].abs_sc, 8);            wr.addBits(slv->dt[i].abs_rt, 3);        }    }    wr.flush();    return wr.m_buf;}

void gen_area(char * map, int size, void (*wr)(char *, int)) {	int i;	int currpos = (map_size_y*(rand()%map_size_y))+rand()%map_size_x;	Position q = to_position(currpos);	for (i = 0; i < size; i++) {		/* The woodlands pattern is as so:		 *  @		 * @#@		 *  @		 * where the @ are replication positions		 */		wr(map, currpos);		int v = rand()%4;		switch (v) {			case 0: currpos = currpos-2; break;			case 1: currpos = currpos+2; break;			case 2: currpos = currpos-map_size_x-map_size_x; break;			case 3: currpos = currpos+map_size_x+map_size_x; break;			default: printf("Randomization error.");break;		}		if (currpos < 0) {			currpos = ((map_size_x*(map_size_y/2))+(map_size_x/2));		}	}	return;}

int main(){	Reader reader1("./res/test.txt");	Reader reader2("./res/test2.txt");	std::string test1reader = reader1.readTextFromFile();	reader2.readTextFromFile();		std::vector<bool> test2reader = reader1.changeBinaryTextToBinary();	std::vector<bool> test3reader = reader2.changeBinaryTextToBinary();		std::vector<bool> text{ 1,1,0,1,0,0,1,1,1,0,1,1,1,0 };	std::vector<bool> polynomial{ 1,0,1,1 };	std::vector<bool> test4reader = crc(text,polynomial);	for (auto x : test4reader)		std::cout << x;	std::cout << "/n";	Writer wr("./res/testwriter.txt");	wr.writeToFile(test1reader);	wr.addToFile(test4reader);	std::cin.get();	return 0;}

void fimg2d4x_set_msk_repeat(struct fimg2d_control *info,				struct fimg2d_repeat *rep){	unsigned long cfg;	if (rep->mode == NO_REPEAT)		return;	cfg = (rep->mode - REPEAT_NORMAL) << FIMG2D_MSK_REPEAT_SHIFT;	wr(cfg, FIMG2D_MSK_REPEAT_MODE_REG);	/* mask pad color */	if (rep->mode == REPEAT_PAD)		wr(rep->pad_color, FIMG2D_MSK_PAD_VALUE_REG);}

int main(int argc, char *argv[]) {  if (argc < 3) {    std::cerr << "Usage: " << argv[0] << " protobufs... avrofile" << std::endl;    return 1;  }  std::string out = argv[argc - 1];  IMP_NPCTRANSPORT_AVRO_NAMESPACE::DataFileWriter<IMP_npctransport::wrapper> wr(      out.c_str(), IMP::npctransport::get_avro_data_file_schema());  for (int i = 0; i < argc - 2; ++i) {    IMP_npctransport::wrapper data;    data.key = "none";    std::ifstream file(argv[i],                       std::ios::in | std::ios::binary | std::ios::ate);    if (!file.is_open()) {      throw std::runtime_error("couldn't open file");    }    data.value.resize(file.tellg());    file.seekg(0, std::ios::beg);    if (!file.read(reinterpret_cast<char *>(&data.value[0]), data.value.size()))      wr.write(data);  }  return 0;}

/* pid filter and transfer stuff */static int dib3000mb_pid_control(struct dvb_frontend *fe,int index, int pid,int onoff){	struct dib3000_state *state = fe->demodulator_priv;	pid = (onoff ? pid | DIB3000_ACTIVATE_PID_FILTERING : 0);	wr(index+DIB3000MB_REG_FIRST_PID,pid);	return 0;}

bool PrefsFile::writePrefVal(const QString &prefId, const QString &newVal) {    if (filePath == NULL)        return false;    QString cnt;    QFileInfo checkFile(filePath);    if (!checkFile.exists()) {        return false;    } else {        QString oldVal = this->fetchPrefVal(prefId);        QFile f(filePath);        if (f.open( QIODevice::ReadWrite )) {            QTextStream rd(&f);            cnt = rd.readAll();        }        f.resize(0); //truncate        f.close();        QString oldL(prefId + " " + oldVal);        QString newL(prefId + " " + newVal);        cnt.replace(oldL, newL);        if (f.open( QIODevice::ReadWrite )) {            QTextStream wr(&f);            wr << cnt;            return true;        }    }}

static int dib3000mb_sleep(struct dvb_frontend* fe){    struct dib3000_state* state = (struct dib3000_state*) fe->demodulator_priv;    wr(DIB3000MB_REG_POWER_CONTROL,DIB3000MB_POWER_DOWN);    return 0;}

void CoinEng::ExportToBootstrapDat(const path& pathBoostrap) {	uint32_t n = Db->GetMaxHeight()+1;	#ifndef X_DEBUG//!!!T	if (Mode == EngMode::Bootstrap) {		CEngStateDescription stateDesc(_self, EXT_STR("Copying " << GetBootstrapPath() << " -> " << pathBoostrap));		return (void)copy_file(GetBootstrapPath(), pathBoostrap, copy_options::overwrite_existing);	}#endif	CEngStateDescription stateDesc(_self, EXT_STR("Exporting " << n << " blocks to " << pathBoostrap));	FileStream fs(pathBoostrap, FileMode::Create, FileAccess::Write);	BinaryWriter wr(fs);	for (uint32_t i=0; i<n && Runned; ++i) {		wr << ChainParams.ProtocolMagic;		MemoryStream ms;		Block block = GetBlockByHeight(i);//!!!?		block.LoadToMemory();//!!!?		EXT_FOR (const Tx& tx, block.Txes) {//!!!?			//			tx.m_pimpl->m_nBytesOfHash = 0;//!!!?		}	//!!!?		block.m_pimpl->m_hash.reset();//!!!?block.m_pimpl->m_txHashesOutNums.clear();		block.Write(BinaryWriter(ms).Ref());		wr << uint32_t(ms.Position);		fs.WriteBuf(ms);	}}