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

Rect Transform::transform(const Rect& bounds) const{    Rect r;    vec2 lt( bounds.left,  bounds.top    );    vec2 rt( bounds.right, bounds.top    );    vec2 lb( bounds.left,  bounds.bottom );    vec2 rb( bounds.right, bounds.bottom );    lt = transform(lt);    rt = transform(rt);    lb = transform(lb);    rb = transform(rb);    r.left   = floorf(min(lt[0], rt[0], lb[0], rb[0]) + 0.5f);    r.top    = floorf(min(lt[1], rt[1], lb[1], rb[1]) + 0.5f);    r.right  = floorf(max(lt[0], rt[0], lb[0], rb[0]) + 0.5f);    r.bottom = floorf(max(lt[1], rt[1], lb[1], rb[1]) + 0.5f);    return r;}

const char* ARMv7DOpcodeLoadStoreRegisterImmediate::format(){    const char* instructionName = opName();    if (!instructionName)        return defaultFormat();    appendInstructionName(opName());    appendRegisterName(rt());    appendSeparator();    appendCharacter('[');    appendRegisterName(rn());    if (immediate5()) {        appendSeparator();        appendUnsignedImmediate(immediate5() << scale());    }    appendCharacter(']');    return m_formatBuffer;}

void CAlmanacDiagramCtrl::DrawStarPos(CDC *pDc, const CRect &rect){	ASSERT(pDc != NULL);	if (pDc==NULL || m_strDir.GetLength()!=4)	{		return;	}	CFont *OldFont = (CFont*)pDc->SelectObject(&m_TextFont);	for (int j=90; j<=360; j+=90)	{		POINT pt;		pt.x = m_centerCircle.x + m_iRadius * sin(j*PI/180);		pt.y = m_centerCircle.y - m_iRadius * cos(j*PI/180);		CRect rt;		rt.SetRect(pt.x-7, pt.y-7, pt.x+7, pt.y+7);		CString str;		str = m_strDir.Mid(j/90-1, 1);		pDc->DrawText(str, &rt, DT_SINGLELINE|DT_CENTER|DT_VCENTER);	}	pDc->SetBkMode(TRANSPARENT);  	pDc->SelectObject(&m_StarFont);	for (int i=0; i<m_iStarNum; i++)	{		POINT pt = CalStarPos(m_StarData[i]);		if (m_StarData[i].tracked == 1)		{			pDc->DrawIcon(pt.x-Icon_Size/2, pt.y-Icon_Size/2, m_hSigStrong);		}		else		{			pDc->DrawIcon(pt.x-Icon_Size/2, pt.y-Icon_Size/2, m_hSigWeak);		}		CRect rt(pt.x-Icon_Size/2, pt.y-Icon_Size/2, 				 pt.x+Icon_Size/2, pt.y+Icon_Size/2);		CString str;		str.Format(_T("%d"), m_StarData[i].id);		pDc->DrawText(str, &rt, DT_SINGLELINE|DT_CENTER|DT_VCENTER);	}	pDc->SelectObject(OldFont);}

int main(int, char**) {   bool not_done = true;  dds::Runtime rt("");  dds::Topic<TempSensorType> topic("TempSensorTopic");  dds::DataReader<TempSensorType> dr(topic);  //[NOTE #1]: Create an instance of the handler  TempSensorDataHandler handler;  auto func =     boost::bind(TempSensorDataHandler::handle_data, &handler, _1);  //[NOTE #2]: Register the handler for the relevant event  auto connection =     dr.connect<on_data_available>(func);    return 0; }

void FcitxQtConnectionPrivate::initialize() {    m_serviceWatcher->setConnection(QDBusConnection::sessionBus());    m_serviceWatcher->addWatchedService(m_serviceName);    QFileInfo info(socketFile());    QDir dir(info.path());    if (!dir.exists()) {        QDir rt(QDir::root());        rt.mkpath(info.path());    }    m_watcher->addPath(info.path());    if (info.exists()) {        m_watcher->addPath(info.filePath());    }    connect(m_watcher, &QFileSystemWatcher::fileChanged,            this, &FcitxQtConnectionPrivate::socketFileChanged);    connect(m_watcher, &QFileSystemWatcher::directoryChanged,            this, &FcitxQtConnectionPrivate::socketFileChanged);    m_initialized = true;}

TEST(Type, RuntimeType) {  HPHP::Transl::RuntimeType rt(new StringData());  Type t = Type::fromRuntimeType(rt);  EXPECT_TRUE(t.subtypeOf(Type::Str));  EXPECT_FALSE(t.subtypeOf(Type::Int));  rt = HPHP::Transl::RuntimeType(HphpArray::GetStaticEmptyArray());  t = Type::fromRuntimeType(rt);  EXPECT_TRUE(t.subtypeOf(Type::Arr));  EXPECT_FALSE(t.subtypeOf(Type::Str));  rt = HPHP::Transl::RuntimeType(true);  t = Type::fromRuntimeType(rt);  EXPECT_TRUE(t.subtypeOf(Type::Bool));  EXPECT_FALSE(t.subtypeOf(Type::Obj));  rt = HPHP::Transl::RuntimeType((int64_t) 1);  t = Type::fromRuntimeType(rt);  EXPECT_TRUE(t.subtypeOf(Type::Int));  EXPECT_FALSE(t.subtypeOf(Type::Dbl));  rt = HPHP::Transl::RuntimeType(DataType::KindOfObject,                                 DataType::KindOfInvalid);  rt = rt.setKnownClass(SystemLib::s_TraversableClass);  t = Type::fromRuntimeType(rt);  EXPECT_TRUE(t.subtypeOf(Type::Obj));  EXPECT_FALSE(Type::Obj.subtypeOf(t));  EXPECT_FALSE(Type::Int.subtypeOf(t));  HPHP::Transl::RuntimeType rt1 =    HPHP::Transl::RuntimeType(DataType::KindOfObject,                              DataType::KindOfInvalid);  rt1 = rt1.setKnownClass(SystemLib::s_IteratorClass);  Type t1 = Type::fromRuntimeType(rt1);  EXPECT_TRUE(t1.subtypeOf(Type::Obj));  EXPECT_TRUE(t1.subtypeOf(t));  EXPECT_FALSE(Type::Obj.subtypeOf(t1));  EXPECT_FALSE(t.subtypeOf(t1));  EXPECT_FALSE(t.subtypeOf(Type::Str));  EXPECT_FALSE(Type::Int.subtypeOf(t));}

sk_sp<GrRenderTargetContext> GrDrawingManager::makeRenderTargetContext(                                                            sk_sp<GrRenderTargetProxy> rtp,                                                            sk_sp<SkColorSpace> colorSpace,                                                            const SkSurfaceProps* surfaceProps) {    if (this->wasAbandoned()) {        return nullptr;    }    // SkSurface catches bad color space usage at creation. This check handles anything that slips    // by, including internal usage. We allow a null color space here, for read/write pixels and    // other special code paths. If a color space is provided, though, enforce all other rules.    if (colorSpace && !SkSurface_Gpu::Valid(fContext, rtp->config(), colorSpace.get())) {        SkDEBUGFAIL("Invalid config and colorspace combination");        return nullptr;    }    bool useDIF = false;    if (surfaceProps) {        useDIF = surfaceProps->isUseDeviceIndependentFonts();    }    if (useDIF && fContext->caps()->shaderCaps()->pathRenderingSupport() &&        rtp->isStencilBufferMultisampled()) {        // TODO: defer stencil buffer attachment for PathRenderingDrawContext        sk_sp<GrRenderTarget> rt(sk_ref_sp(rtp->instantiate(fContext->textureProvider())));        GrStencilAttachment* sb = fContext->resourceProvider()->attachStencilAttachment(rt.get());        if (sb) {            return sk_sp<GrRenderTargetContext>(new GrPathRenderingRenderTargetContext(                                                        fContext, this, std::move(rtp),                                                        std::move(colorSpace), surfaceProps,                                                        fContext->getAuditTrail(), fSingleOwner));        }    }    return sk_sp<GrRenderTargetContext>(new GrRenderTargetContext(fContext, this, std::move(rtp),                                                                  std::move(colorSpace),                                                                  surfaceProps,                                                                  fContext->getAuditTrail(),                                                                  fSingleOwner));}

        ///////////////////////////////////////////////////////////////////////        // priority abp scheduler: local priority deques for each OS thread,        // with work stealing from the "bottom" of each.        int run_priority_abp(startup_function_type const& startup,            shutdown_function_type const& shutdown,            util::command_line_handling& cfg, bool blocking)        {            ensure_hierarchy_arity_compatibility(cfg.vm_);            ensure_hwloc_compatibility(cfg.vm_);            std::size_t num_high_priority_queues = cfg.num_threads_;            if (cfg.vm_.count("hpx:high-priority-threads")) {                num_high_priority_queues =                    cfg.vm_["hpx:high-priority-threads"].as<std::size_t>();            }            bool numa_sensitive = false;            if (cfg.vm_.count("hpx:numa-sensitive"))                numa_sensitive = true;            // scheduling policy            typedef hpx::threads::policies::abp_priority_queue_scheduler                abp_priority_queue_policy;            abp_priority_queue_policy::init_parameter_type init(                cfg.num_threads_, num_high_priority_queues, 1000,                numa_sensitive);            // Build and configure this runtime instance.            typedef hpx::runtime_impl<abp_priority_queue_policy> runtime_type;            HPX_STD_UNIQUE_PTR<hpx::runtime> rt(                new runtime_type(cfg.rtcfg_, cfg.mode_, cfg.num_threads_, init));            if (blocking) {                return run(*rt, cfg.hpx_main_f_, cfg.vm_, cfg.mode_, startup,                    shutdown);            }            // non-blocking version            start(*rt, cfg.hpx_main_f_, cfg.vm_, cfg.mode_, startup, shutdown);            rt.release();          // pointer to runtime is stored in TLS            return 0;        }

int main(int argc, char** argv) {       try {        std::string script = LoadScript(argc, argv);        rs::jsapi::Runtime rt(1024 * 1024 * 1024, true, true);        auto app = new Application(rt, "com.ripcordsoftware.examples.gtk", 1, argv);        rs::jsapi::Global::DefineProperty(rt, "app", *app);        auto builder = new Builder(rt);        rs::jsapi::Global::DefineProperty(rt, "builder", *builder);                rs::jsapi::Global::DefineFunction(rt, "trace",             [](const std::vector<rs::jsapi::Value>& args, rs::jsapi::Value& result){                for (auto arg : args) {                    std::cout << arg.ToString();                }                                if (args.size() > 0) {                    std::cout << std::endl;                }                                return true;            });        rt.Evaluate(script.c_str());                    //rs::jsapi::Script scr(rt, script.c_str());        //scr.Compile();        //scr.Execute();    } catch (const rs::jsapi::ScriptException& ex) {        std::cerr <<             "ERROR: line " << ex.lineno << std::endl <<            ex.what() << std::endl <<            ex.linebuf << std::endl;            }        return 0;}

QSize K3ActiveLabel::minimumSizeHint() const{   QSize ms = minimumSize();   if ((ms.width() > 0) && (ms.height() > 0))      return ms;   int w = 400;   if (ms.width() > 0)      w = ms.width();   QString txt = toHtml();   Q3SimpleRichText rt(txt, font());   rt.setWidth(w - 2*frameWidth() - 10);   w = 10 + rt.widthUsed() + 2*frameWidth();   if (w < ms.width())      w = ms.width();   int h = rt.height() + 2*frameWidth();   if ( h < ms.height())      h = ms.height();   return QSize(w, h);}

void MainWindow::newCellTest(){	QString rts("root"), rrts("right of root and quite long at that"), 		lrts("left of root");	ZZCell rt((cellID)1, 0, rts),	       rrt((cellID)2, 0, rrts),	       lrt((cellID)3, 0, lrts);		// QHash should make a copy for us	// since these guys will be dead soon		world.insert(1, rt);	world.insert(2, rrt);	world.insert(3, lrt);	// Construct our top-level squares		QGraphicsRectItem *rt_rect = new QGraphicsRectItem(0,0,100,20), 			  *rrt_rect = new QGraphicsRectItem(0,0,100,20), 			  *lrt_rect = new QGraphicsRectItem(0,0,100,20);	QGraphicsTextItem *rt_text = new QGraphicsTextItem(rt.getContent(), rt_rect),			  *rrt_text = new QGraphicsTextItem(rrt.getContent(), rrt_rect),			  *lrt_text = new QGraphicsTextItem(lrt.getContent(), lrt_rect);	rt_rect->setPos(420, 420);	rrt_rect->setPos(530, 420);	lrt_rect->setPos(310, 420);	// Add our toplevel squares to our scene	scene->addItem(rt_rect);	scene->addItem(rrt_rect);	scene->addItem(lrt_rect);		scene->update();	ui->zzViewWidget->show();}

bool RegexSourceSink::StartAcquisition(QString dev){    QRegExp rx("(.+)/(.+)(//..+)");    int pos=0;    pos=rx.indexIn(dev);    dir=rx.cap(1);    basename=rx.cap(2);    extension=rx.cap(3);    QRegExp rt("(//d+$)");    pos=rt.indexIn(basename);    basename.truncate(pos);//    qDebug()<<dir<<basename<<rt.cap(1)<<extension;    QString regexString=basename+"//d+"+extension;//    qDebug()<<"Will load files that match"<<regexString;    QRegExp movieRegex(regexString);    QDir basedir(dir);    if (!basedir.exists()) qDebug()<<"Extracted dir does not exist"<<dir;    QStringList filt;    filt<<"*"+extension;    basedir.setNameFilters(filt);    QStringList files=basedir.entryList();    goodFiles=new QStringList;    for (int i=0;i<files.count();i++) {        if (movieRegex.indexIn(files.at(i))!=-1) {            goodFiles->append(files.at(i));        }    }    if (goodFiles->count()==0) qDebug()<<"No matching files found";    index=0;    nFrames=goodFiles->count();    return true;}

	virtual void clientMouseMove(const twPoint& pt){        if(m_drag!=-1){                        twRect rt(twPoint(0,0),getClientRect().size());            bool newHover=rt&&pt;                        int newDrag=pt.y/m_rowHeight;            if(newDrag<0)                newDrag=0;            if(newDrag>=(int)items().size())                newDrag=items().size()-1;                        if(newHover!=m_hover || newDrag!=m_drag){                                invalidateClientRect(rectForItem(m_drag));                invalidateClientRect(rectForItem(newDrag));                m_hover=newHover;                m_drag=newDrag;            }                    }    }

std::list<pBlock> ClearInterval::        discardOutside(Signal::Interval& I){    std::list<pBlock> discarded;    BlockCache::cache_t C = cache_->clone();    for (BlockCache::cache_t::value_type itr : C)    {        pBlock block(itr.second);        Signal::Interval blockInterval = block->getInterval();        Signal::Interval toKeep = I & blockInterval;        bool remove_entire_block = toKeep == Signal::Interval();        bool keep_entire_block = toKeep == blockInterval;        if ( remove_entire_block )        {            discarded.push_back (block);        }        else if ( keep_entire_block )        {        }        else        {            // clear partial block            if( I.first <= blockInterval.first && I.last < blockInterval.last )            {                Region ir = block->getRegion ();                ResampleTexture rt(block->glblock->glTexture ()->getOpenGlTextureId ());                ResampleTexture::Area A(ir.a.time, ir.a.scale, ir.b.time, ir.b.scale);                GlFrameBuffer::ScopeBinding sb = rt.enable(A);                float t = I.last / block->block_layout ().targetSampleRate();                A.x1 = t;                rt.drawColoredArea (A, 0.f);                (void)sb; // RAII            }        }    }    return discarded;}

void Ski_area_gui::draw_lines() const{	int r = sa->get_r();	int c = sa->get_c();	for (int i = 0; i < r; ++i){		for (int j = 0; j < c; ++j){			Graph_lib::Rectangle rt(Point(pos.x + j*width, pos.y + i*height), width, height);			ostringstream oss;			oss << sa->get_height(i + 1, j + 1);			if (comment[i][j] != ""){				oss << '(' << comment[i][j] << ')';			}			Graph_lib::Text t(Point(pos.x + j*width + width / 2, pos.y + i*height + height), oss.str());			if (hl[i][j]){				t.set_color(Graph_lib::Color::white);				rt.set_fill_color(Graph_lib::Color::black);			}			rt.draw();			t.draw();		}	}}

		PlayRequest Session::play( const PlayRequest & rq ) throw( RTSP::Exception::ManagedError )		{			try			{				Session::Lock lk( *this );				Log::debug( "%s: pre-play", getLogName() );				// guess common parameters				PlayRequest rt( rq );				BOOST_FOREACH( SessionMap::iterator::reference sess, _sessions )				{					rt.merge( sess->second->eval( rq ) );					Log::debug("%s: merge: %s", getLogName(), rt.toString().c_str() );				}				Log::debug( "%s: play setup with %s", getLogName(), rt.toString().c_str() );				// set it up				BOOST_FOREACH( SessionMap::iterator::reference sess, _sessions )					sess->second->play( rt );				_playIssued = true;				return rt;			}

			bool operator()(iterator texta, iterator texte, uint64_t pb) const			{				assert ( fs );				pb %= fs;								typename factory_type::wrapper_ptr_type cwb(factory_type::construct(filename,pb));								while ( texta != texte )				{					typename factory_type::int_type const ca = *(texta++);					typename factory_type::int_type const cb = cwb->get();										assert ( ca != factory_type::base_istream_type::traits_type::eof() );					assert ( cb != factory_type::base_istream_type::traits_type::eof() );					if ( ca != cb )						return ca < cb;				}								std::runtime_error rt("CircularSuffixComparator::operator(iterator,iterator,uint64_t): comparison extends beyond end of given text.");				throw rt;			}

void ListViewItem::paintCell(QPainter *p, const QColorGroup &cg, int column, int width, int alignment){  if (text(column).isNull()) {    K3ListViewItem::paintCell(p, cg, column, width, alignment);    int pad = 0;        if (pixmap(column)) {      pad = pixmap(column)->width() + 5;    }        Q3SimpleRichText rt(m_richText[column], p->font());    rt.draw(p, pad, 0, QRect(pad, 0, width, height()), cg);  } else if (m_colors.contains(column)) {    /*QColorGroup _cg(cg);    QColor c = _cg.text();    _cg.setColor(QColorGroup::Text, m_colors[column]);*/    K3ListViewItem::paintCell(p, cg, column, width, alignment);    //_cg.setColor(QColorGroup::Text, c);  } else {    K3ListViewItem::paintCell(p, cg, column, width, alignment);  }}

    void worker_proc()    {        Runtime rt(NULL);        AsyncEvent* p;        m_idleWorkers.dec();        while (true) {            if (m_idleWorkers.inc() > m_max_idle) {                if (m_idleWorkers.dec() > 0)                    break;                m_idleWorkers.inc();            }            p = m_pool.get();            if (m_idleWorkers.dec() == 0)                if (m_idleWorkers.CompareAndSwap(0, 1) == 0)                    new_worker();            p->invoke();        }    }

//! Start subscriptions for this resource.void ResourceCached::startSubscriptions(){   OsSysLog::add(FAC_RLS, PRI_DEBUG,                 "ResourceCached::startSubscriptions URI = '%s'",                 data());   // Create the ContactSet.   mContactSetP = new ContactSet(this,                                 // The URI, which is the UtlString-nature                                 // of a RecourceCached.                                 *(static_cast <UtlString*> (this))      );   // Start the refresh timer.   // Choose a random time between 1/2 and 1 times   // ResourceListServer::getRefreshInterval().   int refresh_time =      (int) ((1.0 + ((float) sRandom.rand()) / RAND_MAX) / 2.0 *             getResourceListServer()->getRefreshInterval());   OsSysLog::add(FAC_RLS, PRI_DEBUG,                 "ResourceCached::startSubscriptions refresh_time = %d",                 refresh_time);   OsTime rt(refresh_time, 0);   mRefreshTimer.oneshotAfter(rt);}

TooN::SO3<>  computeMeanOrientation( const std::vector<TooN::SO3<> > & r){    const size_t N = r.size();    std::vector<TooN::SO3<> > rt(N);    TooN::SO3<>  base = r.front();    TooN::SO3<>  baseInv = base.inverse();    TooN::Vector<3> center = TooN::Zeros;    for(unsigned int i = 0; i < N; i++){        rt[i] = r[i] * baseInv;        center += rt[i].ln();    }    center /= N;    TooN::SO3<> mean(center);    do {        center = TooN::Zeros;        for(unsigned int i = 0; i < N; i++){            TooN::SO3<>  diff = rt[i] * mean.inverse();            center += diff.ln();        }        center /= N;        mean = TooN::SO3<>::exp(center) * mean;    } while(center * center > 1e-12);    return mean * base;}

static sk_sp<GrDrawContext> random_draw_context(GrContext* context,                                                SkRandom* random,                                                const GrCaps* caps) {    GrSurfaceOrigin origin = random->nextBool() ? kTopLeft_GrSurfaceOrigin                                                : kBottomLeft_GrSurfaceOrigin;    int sampleCnt = random->nextBool() ? SkTMin(4, caps->maxSampleCount()) : 0;    GrUniqueKey key;    static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();    GrUniqueKey::Builder builder(&key, kDomain, 2);    builder[0] = origin;    builder[1] = sampleCnt;    builder.finish();    sk_sp<GrTexture> texture(context->textureProvider()->findAndRefTextureByUniqueKey(key));    if (texture) {        sk_sp<GrRenderTarget> rt(sk_ref_sp(texture->asRenderTarget()));        return context->drawContext(std::move(rt));    }    sk_sp<GrDrawContext> drawContext(context->newDrawContext(SkBackingFit::kExact,                                                             kRenderTargetWidth,                                                             kRenderTargetHeight,                                                             kRGBA_8888_GrPixelConfig,                                                             sampleCnt,                                                             origin));    if (!drawContext) {        return nullptr;    }    // TODO: need a real way to do this via the drawContext    texture = drawContext->asTexture();    context->textureProvider()->assignUniqueKeyToTexture(key, texture.get());    return drawContext;}

static void rtbox(double r,double theta,double wtheta,const char *label) {	coord v[4];	double htheta,hr;		htheta=wtheta/2;	hr=r*htheta;	v[0]=rt(r-hr,theta-htheta);	v[1]=rt(r+hr,theta-htheta);	v[2]=rt(r+hr,theta+htheta);	v[3]=rt(r-hr,theta+htheta);		startgroup();	printf("<path "LT" d=/"M%f %f L%f %f L%f %f L%f %f Z/"/>/n",		XY(v[0]),XY(v[1]),XY(v[2]),XY(v[3]));		crosshair(rt(r,theta),5);	text_cen(rt(r+0.8*hr,theta),theta,24,label);	endgroup();}

 iterator at( unsigned int pos_)                      {iterator rt(this); return rt+pos_;}

 iterator begin()                                     {iterator rt(this); return rt;}

//.........这里部分代码省略.........      "//ube44//uc601//ub9ac", "//uc870//uc9c1//uc73c//ub85c//uc11c", "//ud604//ub300",      "//uc18c//ud504//ud2b8//uc6e8//uc5b4", "//uc81c//ud488//uacfc",      "//ud45c//uc900//uc5d0//uc11c", "//ud14d//uc2a4//ud2b8//uc758", "//ud45c//ud604//uc744",      "//uc9c0//uc815//ud558//ub294", "//uc720//ub2c8//ucf54//ub4dc", "//ud45c//uc900//uc758",      "//uc0ac//uc6a9//uc744", "//uac1c//ubc1c//ud558//uace0", "//ud655//uc7a5//ud558//uba70",      "//uc7a5//ub824//ud558//uae30", "//uc704//ud574",      "//uc138//uc6cc//uc84c//uc2b5//ub2c8//ub2e4.", "//ucf58//uc18c//uc2dc//uc5c4",      "//uba64//ubc84//uc27d//uc740", "//ucef4//ud4e8//ud130//uc640", "//uc815//ubcf4",      "//ucc98//ub9ac", "//uc0b0//uc5c5//uc5d0", "//uc885//uc0ac//ud558//uace0", "//uc788//ub294",      "//uad11//ubc94//uc704//ud55c", "//ud68c//uc0ac", "//ubc0f", "//uc870//uc9c1//uc758",      "//ubc94//uc704//ub97c",      "//ub098//ud0c0//ub0c5//ub2c8//ub2e4.", "//ucf58//uc18c//uc2dc//uc5c4//uc758",      "//uc7ac//uc815//uc740", "//uc804//uc801//uc73c//ub85c", "//ud68c//ube44//uc5d0",      "//uc758//ud574", "//ucda9//ub2f9//ub429//ub2c8//ub2e4.", "//uc720//ub2c8//ucf54//ub4dc",      "//ucee8//uc18c//uc2dc//uc5c4//uc5d0//uc11c//uc758", "//uba64//ubc84//uc27d//uc740",      "//uc804", "//uc138//uacc4", "//uc5b4//ub290", "//uacf3//uc5d0//uc11c//ub098",      "//uc720//ub2c8//ucf54//ub4dc", "//ud45c//uc900//uc744", "//uc9c0//uc6d0//ud558//uace0",      "//uadf8", "//ud655//uc7a5//uacfc", "//uad6c//ud604//uc744",      "//uc9c0//uc6d0//ud558//uace0//uc790//ud558//ub294", "//uc870//uc9c1//uacfc",      "//uac1c//uc778//uc5d0//uac8c", "//uac1c//ubc29//ub418//uc5b4",      "//uc788//uc2b5//ub2c8//ub2e4.",      "//ub354", "//uc790//uc138//ud55c", "//ub0b4//uc6a9//uc740", "//uc6a9//uc5b4//uc9d1,",      "//uc608//uc81c", "//uc720//ub2c8//ucf54//ub4dc", "//uc0ac//uc6a9", "//uac00//ub2a5",      "//uc81c//ud488,", "//uae30//uc220", "//uc815//ubcf4", "//ubc0f", "//uae30//ud0c0",      "//uc720//uc6a9//ud55c", "//uc815//ubcf4//ub97c",      "//ucc38//uc870//ud558//uc2ed//uc2dc//uc624."    };    enum { WHAT_IS_UNICODE_length = sizeof(WHAT_IS_UNICODE) / sizeof(WHAT_IS_UNICODE[0]) };    UParseError parseError;    UErrorCode status = U_ZERO_ERROR;    Transliterator* latinJamo = Transliterator::createInstance("Latin-Jamo", UTRANS_FORWARD, parseError, status);    Transliterator* jamoHangul = Transliterator::createInstance("NFC(NFD)", UTRANS_FORWARD, parseError, status);    if (latinJamo == 0 || jamoHangul == 0 || U_FAILURE(status)) {        delete latinJamo;        delete jamoHangul;        dataerrln("FAIL: createInstance returned NULL - %s", u_errorName(status));        return;    }    Transliterator* jamoLatin = latinJamo->createInverse(status);    Transliterator* hangulJamo = jamoHangul->createInverse(status);    if (jamoLatin == 0 || hangulJamo == 0) {        errln("FAIL: createInverse returned NULL");        delete latinJamo;        delete jamoLatin;        delete jamoHangul;        delete hangulJamo;        return;    }    Transliterator* tarray[4] =        { hangulJamo, jamoLatin, latinJamo, jamoHangul };    CompoundTransliterator rt(tarray, 4);        UnicodeString buf;    int32_t total = 0;    int32_t errors = 0;    int32_t i;    for (i=0; i < WHAT_IS_UNICODE_length; ++i) {        ++total;        UnicodeString hangul = UnicodeString(WHAT_IS_UNICODE[i], -1, US_INV);        hangul = hangul.unescape(); // Parse backslash-u escapes        UnicodeString hangulX = hangul;        rt.transliterate(hangulX);        if (hangul != hangulX) {            ++errors;            UnicodeString jamo = hangul; hangulJamo->transliterate(jamo);            UnicodeString latin = jamo; jamoLatin->transliterate(latin);            UnicodeString jamo2 = latin; latinJamo->transliterate(jamo2);            UnicodeString hangul2 = jamo2; jamoHangul->transliterate(hangul2);                        buf.remove(0);            buf.append("FAIL: ");            if (hangul2 != hangulX) {                buf.append((UnicodeString)"(Weird: " + hangulX + " != " + hangul2 + ")");            }            // The Hangul-Jamo conversion is not usually the            // bug here, so we hide it from display.            // Uncomment lines to see the Hangul.            buf.append(//hangul + " => " +                       jamoToName(jamo) + " => " +                       latin + " => " + jamoToName(jamo2)                       //+ " => " + hangul2                       );            errln(prettify(buf));        }    }    if (errors != 0) {        errln((UnicodeString)"Test word failures: " + errors + " out of " + total);    } else {        logln((UnicodeString)"All " + total + " test words passed");    }    delete latinJamo;    delete jamoLatin;    delete jamoHangul;    delete hangulJamo;}

// CLASS METHOD: Interpreter::exec_load_store_instr()// PURPOSE:      Load/store instructions move data between memory and the//               general registers.  They are all encoded as "I-Type"//               instructions, and the only addressing mode implemented is base//               register plus signed, immediate offset.  This directly enables//               the use of three distinct addressing modes: register plus//               offset; register direct; and immediate.//// ARGUMENTS: None.// RETURNS:   None.voidInterpreter::exec_load_store_instr(void){    Word vaddr, paddr;    switch (op(curr_instr))    {        // LB -- Load Byte        //         // Sign-extend 16-bit `offset` and add to contents of register `base` to        // form address.  Sign-extend contents of addressed byte and load into        // `rt`.        case LB:            vaddr = gpr[base(curr_instr)] + sign_ext(curr_instr);            paddr = translate_address(align(vaddr));            do_load(LOADREG, rt(curr_instr), sign_ext_byte(mem->read(vaddr, paddr), bytepos(vaddr)));            break;        // LBU -- Load Byte Unsigned        //        // Sign-extend 16-bit `offse` and add to contents of register `base` to        // form address.  Zero-extend contents of addressed byte and load into        // `rt`.        case LBU:            vaddr = gpr[base(curr_instr)] + sign_ext(curr_instr);            paddr = translate_address(align(vaddr));            do_load(LOADREG, rt(curr_instr), zero_ext_byte(mem->read(vaddr, paddr), bytepos(vaddr)));            break;        // LH -- Load Halfword        //        // Sign-extend 16-bit `offset` and add to contents of register `base` to        // form address.  Sign-extend contents of addressed byte and load into        // `rt`.        case LH:            vaddr = gpr[base(curr_instr)] + sign_ext(curr_instr);            paddr = translate_address(align(vaddr));            do_load(LOADREG, rt(curr_instr), sign_ext_hword(mem->read(vaddr, paddr), hwordpos(vaddr)));            break;        // LHU -- Load Halfword Unsigned        //        // Sign-extend 16-bit `offset` and add to contents of register `base` to        // form address.  Zero-extend contents of addressed byte and load into        // `rt`.        case LHU:            vaddr = gpr[base(curr_instr)] + sign_ext(curr_instr);            paddr = translate_address(align(vaddr));            do_load(LOADREG, rt(curr_instr), zero_ext_hword(mem->read(vaddr, paddr), hwordpos(vaddr)));            break;        // LW -- Load Word        //        // Sign-extend 16-bit `offset` and add to contents of register `base` to        // form address.  Load contents of addressed word into register `rt`.        case LW:            vaddr = gpr[base(curr_instr)] + sign_ext(curr_instr);            paddr = translate_address(align(vaddr));            do_load(LOADREG, rt(curr_instr), mem->read(vaddr, paddr));            break;        // LWL -- Load Word Left        //        // Sign-extend 16-bit `offset` and add to contents of register `base` to        // form address.  Shift addressed word left so that addressed byte is        // leftmost byte of a word.  Merge bytes from memory with contents of        // register `rt` and load result into register `rt`.        case LWL:            vaddr = gpr[base(curr_instr)] + sign_ext(curr_instr);            paddr = translate_address(align(vaddr));            do_load(LOADREG, rt(curr_instr), merge(gpr[rt(curr_instr)], mem->read(vaddr, paddr), bytepos(vaddr), true));            break;        // LWR -- Load Word Right        //        // Sign-extend 16-bit `offset` and add to contents of register `base` to        // form address.  Shfit addressed word right so that addressed byte is        // rightmost byte of a word.  Merge bytes from memory with contents of        // register `rt` and load result into register `rt`.        case LWR:            vaddr = gpr[base(curr_instr)] + sign_ext(curr_instr);            paddr = translate_address(align(vaddr));            do_load(LOADREG, rt(curr_instr), merge(gpr[rt(curr_instr)], mem->read(vaddr, paddr), bytepos(vaddr), false));//.........这里部分代码省略.........

NotesTransferDialog::NotesTransferDialog(int dummy){  notestransferdialog = gtk_dialog_new();  gtk_window_set_title(GTK_WINDOW(notestransferdialog), _("Transfer To Project Notes"));  gtk_window_set_position(GTK_WINDOW(notestransferdialog), GTK_WIN_POS_CENTER_ON_PARENT);  gtk_window_set_modal(GTK_WINDOW(notestransferdialog), TRUE);  dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG(notestransferdialog));  gtk_widget_show(dialog_vbox1);  vbox1 = gtk_vbox_new(FALSE, 5);  gtk_widget_show(vbox1);  gtk_box_pack_start(GTK_BOX(dialog_vbox1), vbox1, FALSE, FALSE, 0);  label1 = gtk_label_new(_("This will transfer all text from the currently opened project into the Project notes."));  gtk_widget_show(label1);  gtk_box_pack_start(GTK_BOX(vbox1), label1, FALSE, FALSE, 0);  gtk_label_set_line_wrap(GTK_LABEL(label1), TRUE);  gtk_misc_set_alignment(GTK_MISC(label1), 0, 0.5);  hbox1 = gtk_hbox_new(FALSE, 5);  gtk_widget_show(hbox1);  gtk_box_pack_start(GTK_BOX(vbox1), hbox1, TRUE, TRUE, 0);  label2 = gtk_label_new(_("The notes will be put into category"));  gtk_widget_show(label2);  gtk_box_pack_start(GTK_BOX(hbox1), label2, FALSE, FALSE, 0);  combobox1 = gtk_combo_box_new_text();  gtk_widget_show(combobox1);  gtk_box_pack_start(GTK_BOX(hbox1), combobox1, TRUE, TRUE, 0);  label3 = gtk_label_new(_("The transfer cannot be undone."));  gtk_widget_show(label3);  gtk_box_pack_start(GTK_BOX(vbox1), label3, FALSE, FALSE, 0);  gtk_misc_set_alignment(GTK_MISC(label3), 0, 0.5);  dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(notestransferdialog));  gtk_widget_show(dialog_action_area1);  gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);  new InDialogHelp(notestransferdialog, NULL, NULL, NULL);  cancelbutton = gtk_button_new_from_stock("gtk-cancel");  gtk_widget_show(cancelbutton);  gtk_dialog_add_action_widget(GTK_DIALOG(notestransferdialog), cancelbutton, GTK_RESPONSE_CANCEL);  gtk_widget_set_can_default (GTK_WIDGET (cancelbutton), true);  okbutton = gtk_button_new_from_stock("gtk-ok");  gtk_widget_show(okbutton);  gtk_dialog_add_action_widget(GTK_DIALOG(notestransferdialog), okbutton, GTK_RESPONSE_OK);  gtk_widget_set_can_default (GTK_WIDGET (okbutton), true);  g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this));  // Read all the categories and add amy new ones from the database.  ReadText rt(notes_categories_filename());  notes_categories_add_from_database(rt.lines);  combobox_set_strings(combobox1, rt.lines);  if (!rt.lines.empty())    combobox_set_string(combobox1, rt.lines[0]);}