int main(int argc, char **argv) { if (argc != 3) { fprintf(stderr, "Usage: %s FILE.mo STRING\n", argv[0]); return 1; } #ifdef _UNICODE TCHAR path[PATH_MAX]; int length = ::MultiByteToWideChar(CP_ACP, 0, argv[1], -1, path, PATH_MAX); if (length == 0) return 2; #else const char *path = argv[1]; #endif const char *original = argv[2]; MOFile mo(path); if (mo.error()) { fprintf(stderr, "Failed to load %s\n", path); return 2; } const char *translated = mo.lookup(original); if (translated == NULL) { fprintf(stderr, "No such string\n"); return 3; } puts(translated); return 0; }
int main(int argc, char** argv) { if (argc < 2) { cout << "syntax: initialMomentumMatching param_file1" << endl ; exit(1) ; } Shooting mo(argv[1], argc, argv) ; mo.initialPrint() ; Vector Z, Z0 ; if (mo.param.foundInitialMomentum) { Z0.read(mo.param.fileInitialMom) ; } else if (mo.param.cont){ char file[256] ; sprintf(file, "%s/initialScalarMomentum", mo.param.outDir) ; Z0.read(file) ; } else { Z0.al(mo.Template.domain()); Z0.zero(); } // mo.downscale(Z0) ; // int nbiter = mo.param.nb_iter ; // mo.param.nb_iter = 15 ; mo.gradientImageMatching(Z0) ; // mo.upscale(mo.Z0) ; // mo.param.nb_iter = nbiter ; //mo.gradDesc(Z0, Z, mo.param.nb_iter, 0.001, mo.param.epsMax, mo.param.minVarEn, mo.param.gs, mo.param.verb, (void *) &(mo.param)) ; mo.Print() ; }
static PyObject *Triton_convertMemToSymVar(PyObject *self, PyObject *args) { PyObject *memAddr, *symVarSize, *varComment = nullptr; uint64 vs; std::string vc; /* Extract arguments */ PyArg_ParseTuple(args, "O|O|O", &memAddr, &symVarSize, &varComment); if (varComment == nullptr) varComment = PyString_FromString(""); if (!PyLong_Check(memAddr) && !PyInt_Check(memAddr)) return PyErr_Format(PyExc_TypeError, "convertMemToSymVar(): expected a memory address as first argument"); if (!PyLong_Check(symVarSize) && !PyInt_Check(symVarSize)) return PyErr_Format(PyExc_TypeError, "convertMemToSymVar(): expected a size as second argument"); if (!PyString_Check(varComment)) return PyErr_Format(PyExc_TypeError, "convertMemToSymVar(): expected a comment (string) as third argument"); vs = PyLong_AsLong(symVarSize); vc = PyString_AsString(varComment); MemoryOperand mo(PyLong_AsLong(memAddr), vs); return PySymbolicVariable(ap.convertMemToSymVar(mo, vs, vc)); }
MetaObject MetaObject::Copy() const { MetaObject mo(*this); MetaState *newstate=new MetaState(*this->_state); mo._state.reset(newstate); return mo; }
int Scheduler::svc (void) { for (;;) { // Dequeue the next method request (we use an auto pointer in // case an exception is thrown in the <call>). ACE_Method_Request *mo_p = this->activation_queue_.dequeue (); if (0 == mo_p) { ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%t) activation queue shut down\n"))); break; } auto_ptr<ACE_Method_Request> mo (mo_p); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%t) calling method request\n"))); // Call it. if(mo->call () == -1) break; // Destructor automatically deletes it. } return 0; }
ResPolyRing* readRing(std::istream& infile) { // Hack job. // Input format: // <characteristic> // <n:#variables> // <weight_0> <weight_1> ... <weight_(n-1)> // grevlex | lex | ... int charac; int nvars; infile >> charac; infile >> nvars; std::vector<int> wts(nvars); for (int i=0; i<nvars; i++) { int a; infile >> a; wts.push_back(a); } MonomialOrdering mo(nvars, wts); MonomialInfo M(mo); M2::ARingZZp kk(101); ResGausser G(kk); ResPolyRing* R = new ResPolyRing(G,M); return R; }
void MainWindow::on_actionResizeMap_triggered(){ if(!map.isLoaded())return; DialogResizeMap dlg(map.getWidth(),map.getHeight()); if(dlg.exec()!=QDialog::Accepted)return; MoResizeMap mo(dlg.mapWidth,dlg.mapHeight,dlg.hAlign,dlg.vAlign); mo.toolTip=tr("Resize Map"); doOperation(&mo); }
void MainWindow::editItemScripts(u8 itemId){ DialogScripts dlg(map.itemAt(itemId).scripts,this); dlg.setWindowTitle(QString(tr("Scripts for item#%1")).arg(itemId)); if(dlg.exec()==QDialog::Accepted){ MoEditItemScript mo(dlg.scripts,itemId); mo.toolTip=QString(tr("Edit Scripts for item#%1")).arg(itemId); doOperation(&mo); } }
static PyObject *Triton_taintMem(PyObject *self, PyObject *mem) { if (!PyLong_Check(mem) && !PyInt_Check(mem)) return PyErr_Format(PyExc_TypeError, "TaintMem(): expected a memory address (integer) as argument"); MemoryOperand mo(PyInt_AsLong(mem), 1); ap.taintMem(mo); Py_INCREF(Py_None); return Py_None; }
static PyObject *Triton_isMemTainted(PyObject *self, PyObject *mem) { if (!PyLong_Check(mem) && !PyInt_Check(mem)) return PyErr_Format(PyExc_TypeError, "isMemTainted(): expected an address (integer) as argument"); MemoryOperand mo(PyInt_AsLong(mem), 1); if (ap.isMemTainted(mo) == true) Py_RETURN_TRUE; Py_RETURN_FALSE; }
// Get a multioverlap object representing the overlaps for this vertex MultiOverlap Vertex::getMultiOverlap() const { MultiOverlap mo(getID(), getSeq().toString()); for(size_t i = 0; i < m_edges.size(); ++i) { Edge* pEdge = m_edges[i]; mo.add(pEdge->getEnd()->getSeq().toString(), pEdge->getOverlap()); } return mo; }
void MainWindow::on_buttonItemDelete_clicked() { if(!map.isLoaded())return; QModelIndex selection=ui->itemTable->currentIndex(); if(!selection.isValid())return; u8 selItem=selection.row(); if(selItem>=map.getItemCount())return; MoDeleteItem mo(selItem); mo.toolTip=QString(tr("Remove Item#%1")).arg(selItem); doOperation(&mo); }
void MainWindow::on_actionMapProperties_triggered() { if(!map.isLoaded()){ return; } DialogProperties dlg(map.metaData); if(QDialog::Accepted==dlg.exec()){ MoEditMetaData mo(dlg.metaData); mo.toolTip=tr("Change Properties"); doOperation(&mo); } }
int Logger::svc(void) { while(1) { auto_ptr<ACE_Method_Request> mo(this->activation_queue_.dequeue()); ACE_DEBUG((LM_DEBUG, "(%t) calling method object\n")); if(mo->call() == -1) break; } return 0; }
VideoVisual::VideoVisual( const std::string &name, rendering::VisualPtr parent, int height, int width) : rendering::Visual(name, parent), height_(height), width_(width) { texture_ = Ogre::TextureManager::getSingleton().createManual( name + "__VideoTexture__", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, width_, height_, 0, Ogre::PF_BYTE_BGRA, Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE); Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().create( name + "__VideoMaterial__", "General"); material->getTechnique(0)->getPass(0)->createTextureUnitState( name + "__VideoTexture__"); material->setReceiveShadows(false); double factor = 1.0; Ogre::ManualObject mo(name + "__VideoObject__"); mo.begin(name + "__VideoMaterial__", Ogre::RenderOperation::OT_TRIANGLE_LIST); mo.position(-factor / 2, factor / 2, 0.51); mo.textureCoord(0, 0); mo.position(factor / 2, factor / 2, 0.51); mo.textureCoord(1, 0); mo.position(factor / 2, -factor / 2, 0.51); mo.textureCoord(1, 1); mo.position(-factor / 2, -factor / 2, 0.51); mo.textureCoord(0, 1); mo.triangle(0, 3, 2); mo.triangle(2, 1, 0); mo.end(); mo.convertToMesh(name + "__VideoMesh__"); Ogre::MovableObject *obj = (Ogre::MovableObject*) this->GetSceneNode()->getCreator()->createEntity( name + "__VideoEntity__", name + "__VideoMesh__"); obj->setCastShadows(false); this->AttachObject(obj); }
int Dispatch(int argc, const char* const argv[]) { CommandLine cl(argc, argv); LOG(info) << cl; ModuleOptions mo(cl); std::ostream& os = mo.help() ? std::cout : std::cerr; if (not mo.valid() or mo.help()) { os << mo << std::endl; return 1; } return Modules::Run(mo.module(), cl); }
void MainWindow::on_buttonItemDown_clicked() { if(!map.isLoaded())return; QModelIndex selection=ui->itemTable->currentIndex(); if(!selection.isValid())return; u8 selItem=selection.row(); if(selItem==map.getItemCount()-1)return; if(selItem>=map.getItemCount())return; MoSwapItem mo(selItem); mo.toolTip=QString(tr("Move down Item#%1")).arg(selItem); doOperation(&mo); ui->itemTable->setCurrentIndex(itemTableModal.getIndex(selItem+1,selection.column())); }
void test_move() { #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES std::deque<MoveOnly, stack_allocator<MoveOnly, 2000> > c; typedef std::deque<MoveOnly>::const_iterator CI; { MoveOnly mo(0); typedef MoveOnly* I; c.insert(c.end(), std::move_iterator<I>(&mo), std::move_iterator<I>(&mo+1)); } int j = 0; for (CI i = c.begin(); i != c.end(); ++i, ++j) assert(*i == MoveOnly(j)); { MoveOnly mo(1); typedef input_iterator<MoveOnly*> I; c.insert(c.end(), std::move_iterator<I>(I(&mo)), std::move_iterator<I>(I(&mo+1))); } j = 0; for (CI i = c.begin(); i != c.end(); ++i, ++j) assert(*i == MoveOnly(j)); #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES }
LabelsHolder::LabelsHolder() { // Creating point mesh for all labels to cling to static bool isNoMesh = true; if( isNoMesh ) { ManualObject mo("TilePoint"); mo.begin("BaseWhiteNoLighting", RenderOperation::OT_POINT_LIST); mo.position(0, 0, 0); mo.end(); mo.convertToMesh(labelsPointMeshName); isNoMesh = false; } }
//--------------------------------------------------------------------- void PFile::addGroups( Ogre::Mesh *mesh, const String &bone_name ,const RSDFilePtr &rsd ) const { const Ogre::SkeletonPtr skeleton( mesh->getSkeleton() ); const String material_base_name( rsd->getMaterialBaseName() ); String rsd_base; StringUtil::splitBase( rsd->getName(), rsd_base ); ManualObject mo( mesh ); for( size_t g(0); g < m_groups.size(); ++g ) { const String sub_name( bone_name + "/" + rsd_base + "/" + Ogre::StringConverter::toString(g) ); addGroup( m_groups[g], mo, sub_name, material_base_name, skeleton->getBone( bone_name ) ); } }
void MainWindow::on_buttonItemNew_clicked() { if(!map.isLoaded())return; KfMap::RipeItem item; QSize size=ui->mapViewScrollArea->size(); int tx=(ui->mapViewScrollArea->horizontalScrollBar()->value()+size.width()/2); item.basic.x=(tx>=0?tx:0); int ty=(ui->mapViewScrollArea->verticalScrollBar()->value()+size.height()/2); item.basic.y=(ty>=0?ty:0); if(item.basic.x>map.getWidth()*24)item.basic.x=map.getWidth()*24; if(item.basic.y>map.getHeight()*24)item.basic.y=map.getHeight()*24; MoNewItem mo(map.getItemCount(),item); mo.toolTip=tr("Add Item"); doOperation(&mo); ui->itemTable->setCurrentIndex(itemTableModal.getIndex( map.getItemCount()-1,0)); }
Ogre::ManualObject MeshUtils::createWire(const Ogre::MeshPtr& mesh) { Ogre::ManualObject mo("ManualObject"); MeshData* md = MeshUtils::getMeshData(mesh); mo.begin("BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_LIST); for(unsigned int i=0; i<md->triangleCount; i++) { Ogre::Vector3 v = md->triangles[i]; mo.position(v.x, v.y, v.z); std::cout << v << std::endl; } mo.end(); return mo; }
int Prime_Scheduler::svc (void) { for (;;) { // Dequeue the next method request (we use an auto pointer in // case an exception is thrown in the <call>). auto_ptr<ACE_Method_Request> mo (this->activation_queue_.dequeue ()); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) calling method request\n"))); // Call it. if (mo->call () == -1) break; // Destructor automatically deletes it. } /* NOTREACHED */ return 0; }
wxMenu* TBIUpdateMenu::createMenu(uint32 &lastMenuId) { calcUpdates(); gcMenu* menu = new gcMenu(); gcWString m(L"{0} - {1}", Managers::GetString(L"#TB_MESSAGE"), messageCount); gcWString u(L"{0} - {1}", Managers::GetString(L"#TB_UPDATES"), updateCount); gcWString g(L"{0} - {1}", Managers::GetString(L"#TB_GAMES"), gameUpdateCount); gcWString mo(L"{0} - {1}", Managers::GetString(L"#TB_MODS"), modUpdateCount); gcWString c(L"{0} - {1}", Managers::GetString(L"#TB_CART"), cartCount); menu->Append(mcMENU_GAMEUPDATE, g.c_str()); menu->Append(mcMENU_MODUPDATE, mo.c_str()); menu->AppendSeparator(); menu->Append(mcMENU_MESSAGE, m.c_str()); menu->Append(mcMENU_UPDATE, u.c_str()); menu->Append(mcMENU_CART, c.c_str()); return menu; }
void CObjPropsCanvas::RefreshByRemovingAndAddingAll2(){ ClearProperties(); wxGetApp().m_frame->ClearToolBar(m_toolBar); HeeksObj* marked_object = NULL; if(wxGetApp().m_marked_list->size() == 1) { marked_object = (*wxGetApp().m_marked_list->list().begin()); } if(m_make_initial_properties_in_refresh)ClearInitialProperties(); if(wxGetApp().m_marked_list->size() > 0) { // use the property list too std::list<Property *> list; wxGetApp().m_marked_list->GetProperties(&list); for(std::list<Property*>::iterator It = list.begin(); It != list.end(); It++) { Property* property = *It; if(m_make_initial_properties_in_refresh)m_initial_properties.push_back(property->MakeACopy()); AddProperty(property); } // add toolbar buttons std::list<Tool*> t_list; MarkedObjectOneOfEach mo(0, marked_object, 1, 0, NULL); if (wxGetApp().m_marked_list->size() == 1)mo.GetObject()->GetTools(&t_list, NULL); else wxGetApp().m_marked_list->GetTools(&mo, t_list, NULL, false); for (std::list<Tool*>::iterator It = t_list.begin(); It != t_list.end(); It++) { Tool* tool = *It; if(tool)wxGetApp().m_frame->AddToolBarTool(m_toolBar, tool); } m_toolBar->Realize(); } Resize(); }
int main(int argc, char **argv) { Args args(argc, argv, "FILE.igc STRING"); const char *narrow_path = args.PeekNext(); tstring path = args.ExpectNextT(); const char *original = args.ExpectNext(); args.ExpectEnd(); MOLoader mo(path.c_str()); if (mo.error()) { fprintf(stderr, "Failed to load %s\n", narrow_path); return 2; } const char *translated = mo.get().lookup(original); if (translated == NULL) { fprintf(stderr, "No such string\n"); return 3; } puts(translated); return 0; }
int main(int argc, char** argv) { if (argc < 2) { cout << "syntax: velocityMatching param_file" << endl ; exit(1) ; } Velocity mo(argv[1], argc, argv) ; // mo.param.read(argc, argv) ; // mo.param.verb= 1 ; mo.initialPrint() ; // cout << "starting matching" << endl ; mo.matching() ; // mo.gradientImageMatching(mo.Z0) ; // mo.PrintTime(mo.Lv0) ; }
int sc_main(int argc, char *argv[]) { sc_signal<bool> t_enable; sc_signal<sc_uint<2> > t_sel; sc_signal<sc_uint<4> > t_z; decoder d("decoder"); d.enable(t_enable); d.select(t_sel); d.z(t_z); driver dr("driver"); dr.d_enable(t_enable); dr.d_select(t_sel); monitor mo("monitor"); mo.m_enable(t_enable); mo.m_select(t_sel); mo.m_z(t_z); sc_start(100, SC_NS); return (0); }
static PyObject *Triton_setMemValue(PyObject *self, PyObject *args) { PyObject *addr; PyObject *value; PyObject *writeSize; uint128 va; // value uint64 ad; // address uint64 ws; // write size /* Extract arguments */ PyArg_ParseTuple(args, "O|O|O", &addr, &writeSize, &value); if (!PyLong_Check(addr) && !PyInt_Check(addr)) return PyErr_Format(PyExc_TypeError, "setMemValue(): expected an address (integer) as first argument"); if (!PyLong_Check(writeSize) && !PyInt_Check(writeSize)) return PyErr_Format(PyExc_TypeError, "setMemValue(): expected an integer as second argument"); if (!PyLong_Check(value) && !PyInt_Check(value)) return PyErr_Format(PyExc_TypeError, "setMemValue(): expected an integer as third argument"); ad = PyLong_AsLong(addr); ws = PyLong_AsLong(writeSize); if (ws != DQWORD_SIZE && ws != QWORD_SIZE && ws != DWORD_SIZE && ws != WORD_SIZE && ws != BYTE_SIZE) return PyErr_Format(PyExc_TypeError, "setMemValue(): The writeSize argument must be: DQWORD, QWORD, DWORD, WORD or BYTE"); if (PIN_CheckWriteAccess(reinterpret_cast<void*>(ad)) == false) return PyErr_Format(PyExc_TypeError, "setMemValue(): Can not write into the targeted address memory"); va = PyLongObjectToUint128(value); MemoryOperand mo(ad, ws); ap.setMemValue(mo, ws, va); Py_INCREF(Py_None); return Py_None; }
OptionalModelObject ReverseTranslator::translateSetpointManagerMixedAir( const WorkspaceObject & workspaceObject ) { if( workspaceObject.iddObject().type() != IddObjectType::SetpointManager_MixedAir ) { LOG(Error, "WorkspaceObject is not IddObjectType: SetpointManager_MixedAir"); return boost::none; } bool nodeFound = false; if( boost::optional<std::string> setpointNodeName = workspaceObject.getString(SetpointManager_MixedAirFields::SetpointNodeorNodeListName) ) { boost::optional<Node> setpointNode = m_model.getModelObjectByName<Node>(setpointNodeName.get()); if( setpointNode ) { nodeFound = true; } } if( ! nodeFound ) { LOG(Error, workspaceObject.briefDescription() << " is not attached to a node in the model"); return boost::none; } SetpointManagerMixedAir mo(m_model); boost::optional<std::string> s = workspaceObject.getString(SetpointManager_MixedAirFields::Name); if( s ) { mo.setName(s.get()); } s = workspaceObject.getString(SetpointManager_MixedAirFields::ReferenceSetpointNodeName); if( s ) { boost::optional<Node> node = m_model.getModelObjectByName<Node>(s.get()); if( node ) { mo.setReferenceSetpointNode(node.get()); } } s = workspaceObject.getString(SetpointManager_MixedAirFields::FanInletNodeName); if( s ) { boost::optional<Node> node = m_model.getModelObjectByName<Node>(s.get()); if( node ) { mo.setFanInletNode(node.get()); } } s = workspaceObject.getString(SetpointManager_MixedAirFields::FanOutletNodeName); if( s ) { boost::optional<Node> node = m_model.getModelObjectByName<Node>(s.get()); if( node ) { mo.setFanOutletNode(node.get()); } } s = workspaceObject.getString(SetpointManager_MixedAirFields::SetpointNodeorNodeListName); if( s ) { boost::optional<Node> node = m_model.getModelObjectByName<Node>(s.get()); if( node ) { mo.addToNode(node.get()); } } if( mo.setpointNode() ) { return mo; } else { return boost::none; } }