Ejemplo n.º 1
0
    Expression ESolver::CreateExpression(const string& OperatorName,
                                         const Expression& Exp1,
                                         const Expression& Exp2,
                                         const Expression& Exp3)
    {
        // special case for bv extract

        if (OperatorName == "bvextract") {
            if (Exp2->As<UserConstExpression>() == nullptr ||
                Exp3->As<UserConstExpression>() == nullptr) {
                throw TypeException((string)"bvextract can only be applied to constant indices");
            }
            if (Exp2->GetType() != IntType ||
                Exp3->GetType() != IntType) {
                throw TypeException((string)"bvextract can only be applied to constant integer indices");
            }

            auto OpName = BVLogic::GetExtractOpName(Exp1->GetType(), 
                                                    Exp2->GetOp()->As<ConstOperator>()->GetConstantValue()->GetValue(), 
                                                    Exp3->GetOp()->As<ConstOperator>()->GetConstantValue()->GetValue());
            // recurse with new name
            auto Op = LookupOperator(OpName);
            if (Op == nullptr) {
                LoadedBVLogic->InstantiateExtractOperator(Exp1->GetType(), 
                                                          Exp2->GetOp()->As<ConstOperator>()->GetConstantValue()->GetValue(), 
                                                          Exp3->GetOp()->As<ConstOperator>()->GetConstantValue()->GetValue());
                Op = LookupOperator(OpName);
            }
            vector<Expression> Children = { Exp1 };
            return CreateExpression(Op, Children);
        }

        vector<Expression> Children(3);
        Children[0] = Exp1;
        Children[1] = Exp2;
        Children[2] = Exp3;
        return CreateExpression(OperatorName, Children);
    }
Ejemplo n.º 2
0
vector<Book*> BookList::Children ( Book* book )
{
    vector<Book*> ret;

    if ( book->IsDir() )
    {
        vector<Book*> children = book->getChildren();

        for ( vector<Book*>::iterator it=children.begin() ; it < children.end(); ++it )
        {
            if ( (*it)->IsDir() )
            {
                vector<Book*> ch = Children( *it );
                ret.insert( ret.end(), ch.begin(), ch.end() );
            }
            else
            {
                ret.push_back(*it);
            }
        }
    }

    return ret;
}
Ejemplo n.º 3
0
void CUsbDkHubFilterStrategy::RegisterNewChild(PDEVICE_OBJECT PDO)
{
    CWdmUsbDeviceAccess pdoAccess(PDO);

    auto Port = pdoAccess.GetAddress();

    if (Port == CWdmDeviceAccess::NO_ADDRESS)
    {
        TraceEvents(TRACE_LEVEL_ERROR, TRACE_FILTERDEVICE, "%!FUNC! Cannot read device port number");
        return;
    }

    auto Speed = UsbDkWdmUsbDeviceGetSpeed(PDO, m_Owner->GetDriverObject());
    if (Speed == NoSpeed)
    {
        TraceEvents(TRACE_LEVEL_ERROR, TRACE_FILTERDEVICE, "%!FUNC! Cannot query device speed");
        return;
    }

    USB_DEVICE_DESCRIPTOR DevDescriptor;
    auto status = pdoAccess.GetDeviceDescriptor(DevDescriptor);
    if (!NT_SUCCESS(status))
    {
        TraceEvents(TRACE_LEVEL_ERROR, TRACE_FILTERDEVICE, "%!FUNC! Cannot query device descriptor");
        return;
    }

    CObjHolder<CRegText> DevID;
    CObjHolder<CRegText> InstanceID;
    if (!UsbDkGetWdmDeviceIdentity(PDO, &DevID, &InstanceID))
    {
        TraceEvents(TRACE_LEVEL_ERROR, TRACE_FILTERDEVICE, "%!FUNC! Cannot query device identity");
        return;
    }

    TraceEvents(TRACE_LEVEL_INFORMATION, TRACE_FILTERDEVICE, "%!FUNC! Registering new child (PDO: %p):", PDO);
    DevID->Dump();
    InstanceID->Dump();

    CUsbDkChildDevice::TDescriptorsCache CfgDescriptors(DevDescriptor.bNumConfigurations);

    if (!CfgDescriptors.Create())
    {
        TraceEvents(TRACE_LEVEL_ERROR, TRACE_FILTERDEVICE, "%!FUNC! Cannot create descriptors cache");
        return;
    }

    if (!FetchConfigurationDescriptors(pdoAccess, CfgDescriptors))
    {
        TraceEvents(TRACE_LEVEL_ERROR, TRACE_FILTERDEVICE, "%!FUNC! Cannot fetch configuration descriptors");
        return;
    }

    CUsbDkChildDevice *Device = new CUsbDkChildDevice(DevID, InstanceID, Port, Speed, DevDescriptor,
                                                      CfgDescriptors, *m_Owner, PDO);

    if (Device == nullptr)
    {
        TraceEvents(TRACE_LEVEL_ERROR, TRACE_FILTERDEVICE, "%!FUNC! Cannot allocate child device instance");
        return;
    }

    DevID.detach();
    InstanceID.detach();

    Children().PushBack(Device);

    ApplyRedirectionPolicy(*Device);
}
Ejemplo n.º 4
0
Expr *Expr::FoldConstants(void) {
    Expr *n = AllocExpr();
    *n = *this;

    int c = Children();
    if(c >= 1) n->a = a->FoldConstants();
    if(c >= 2) n->b = b->FoldConstants();

    switch(op) {
        case PARAM_PTR:
        case PARAM:
        case CONSTANT:
            break;

        case MINUS:
        case TIMES:
        case DIV:
        case PLUS:
            // If both ops are known, then we can evaluate immediately
            if(n->a->op == CONSTANT && n->b->op == CONSTANT) {
                double nv = n->Eval();
                n->op = CONSTANT;
                n->v = nv;
                break;
            }
            // x + 0 = 0 + x = x
            if(op == PLUS && n->b->op == CONSTANT && Tol(n->b->v, 0)) {
                *n = *(n->a); break;
            }
            if(op == PLUS && n->a->op == CONSTANT && Tol(n->a->v, 0)) {
                *n = *(n->b); break;
            }
            // 1*x = x*1 = x
            if(op == TIMES && n->b->op == CONSTANT && Tol(n->b->v, 1)) {
                *n = *(n->a); break;
            }
            if(op == TIMES && n->a->op == CONSTANT && Tol(n->a->v, 1)) {
                *n = *(n->b); break;
            }
            // 0*x = x*0 = 0
            if(op == TIMES && n->b->op == CONSTANT && Tol(n->b->v, 0)) {
                n->op = CONSTANT; n->v = 0; break;
            }
            if(op == TIMES && n->a->op == CONSTANT && Tol(n->a->v, 0)) {
                n->op = CONSTANT; n->v = 0; break;
            }

            break;

        case SQRT:
        case SQUARE:
        case NEGATE:
        case SIN:
        case COS:
        case ASIN:
        case ACOS:
            if(n->a->op == CONSTANT) {
                double nv = n->Eval();
                n->op = CONSTANT;
                n->v = nv;
            }
            break;

        default: oops();
    }
    return n;
}
Ejemplo n.º 5
0
// private void InitializeUX() [instance] :10
void Nakamura::InitializeUX()
{
    ::g::Fuse::Controls::Image* temp = ::g::Fuse::Controls::Image::New2();
    temp->File(::g::Uno::UX::BundleFileSource::New1(::g::MyFirstProject_bundle::nakamurae464ba9f()));
    ::g::Uno::Collections::ICollection::Add_ex(uInterface(uPtr(Children()), ::g::Uno::Collections::ICollection_typeof()->MakeType(::TYPES[4/*Fuse.Node*/])), temp);
}
Ejemplo n.º 6
0
 Children children() const { return Children(); }
Ejemplo n.º 7
0
void GalaxySetupPanel::Disable(bool b/* = true*/) {
    for (std::list<GG::Wnd*>::const_iterator it = Children().begin(); it != Children().end(); ++it)
        static_cast<GG::Control*>(*it)->Disable(b);
}
Ejemplo n.º 8
0
		/***********************
		 * elix::path::Children
		 @ std::string path
		 @ std::string subpath
		 @ std::vector<std::string> & list
		 @ bool deep
		 @ bool storepath
		 @ bool storedirectories
		 - return true if it's a directory exist
		*/
		bool Children( std::string path, std::string sub_path, std::vector<std::string> & list, bool deep, bool storepath, bool storedirectories )
		{
			dirent * entry = NULL;
			std::string dir_path = path + ELIX_DIR_SSEPARATOR + sub_path;
			std::string file_path = path;
			DIR * dir = opendir( dir_path.c_str() );

			if ( !dir )
			{
				return false;
			}

			while ( (entry = readdir(dir)) != NULL )
			{
				if ( (strcmp(entry->d_name, ".") != 0) && (strcmp(entry->d_name, "..") != 0) )
				{
					file_path = dir_path + ELIX_DIR_SSEPARATOR + entry->d_name;
					if ( elix::path::Exist( file_path ) )
					{
						if ( deep )
						{
							std::string dir_store(entry->d_name);
							Children( path, dir_store, list, false, storepath, storedirectories );
						}
						if ( storedirectories )
						{
							std::string name_store;

							if ( storepath )
							{
								name_store = file_path + ELIX_DIR_SSEPARATOR;
							}
							else if ( sub_path.length() )
							{
								name_store = sub_path + ELIX_DIR_SSEPARATOR + entry->d_name + ELIX_DIR_SSEPARATOR;
							}
							else
							{
								name_store =  entry->d_name;
								name_store.append(ELIX_DIR_SSEPARATOR);
							}
							list.push_back( name_store );
						}
					}
					else
					{
						std::string name_store;
						if ( storepath )
						{
							name_store = file_path;
						}
						else if ( sub_path.length() )
						{
							name_store = sub_path + ELIX_DIR_SSEPARATOR + entry->d_name;
						}
						else
						{
							name_store = entry->d_name;
						}
						list.push_back( name_store );
					}
				}
			}
			closedir(dir);
			return true;
		}