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;
}
}
