예제 #1
0
        public override bool Match(IMatchTarget matchTarget)
        {
            string nativeSignature;

            if (matchTarget is SignatureInfoMatchTarget)
            {
                SignatureInfoMatchTarget sigInfoMatchTarget = matchTarget as SignatureInfoMatchTarget;
                nativeSignature = sigInfoMatchTarget.NativeSignature;
            }
            else
            {
                throw new CannotApplyConditionToMatchTargetException(this, matchTarget);
            }
            return(m_operator.IsTrue("" + nativeSignature, m_value));
        }
예제 #2
0
        public override bool Match(IMatchTarget matchTarget)
        {
            int parameterIndex = 0;

            if (matchTarget is SignatureInfoMatchTarget)
            {
                SignatureInfoMatchTarget sigInfoMatchTarget = matchTarget as SignatureInfoMatchTarget;
                parameterIndex = sigInfoMatchTarget.NativeParameterIndex;
            }
            else
            {
                throw new CannotApplyConditionToMatchTargetException(this, matchTarget);
            }
            return(m_operator.IsTrue("" + parameterIndex, m_value));
        }
예제 #3
0
 private NativeParameterIndexCondition GetNativeParameterIndexCondition(
     SignatureInfoMatchTarget signatureInfoMatchTarget)
 {
     NativeParameterIndexConditionDef parameterIndexConditionDef =
         NativeParameterIndexConditionDef.GetInstance();
     var parameterIndexCondition =
         parameterIndexConditionDef.Create() as NativeParameterIndexCondition;
     parameterIndexCondition.Operator = EqualOperator.GetInstance();
     parameterIndexCondition.Value = "" + signatureInfoMatchTarget.NativeParameterIndex;
     return parameterIndexCondition;
 }
        private static void ProcessFuncParams(TypeInfo interfaceTypeInfo,
            int funcIndex, TreeNode parentTreeNode)
        {
            int paramIndex = 0;
            FuncDesc funcDesc = interfaceTypeInfo.GetFuncDesc(funcIndex);
            ElemDesc retElemDesc = funcDesc.elemdescFunc;
            SignatureInfoMatchTarget retSignatureInfo = new SignatureInfoMatchTarget(interfaceTypeInfo,
                funcIndex, retElemDesc, paramIndex);
            TreeNode retTreeNode = new TreeNode();
            string typeString =
                    (new TlbType2String(interfaceTypeInfo, retElemDesc.tdesc)).GetTypeString();
            retTreeNode.Text = typeString + "  " + retSignatureInfo.Name +
                    ": " + retSignatureInfo.Type;
            retTreeNode.Tag = retSignatureInfo;
            SetTlbTreeNodeImage(retTreeNode);
            parentTreeNode.Nodes.Add(retTreeNode);
            ++paramIndex;
            // Parameters
            //string[] signatureNames = interfaceTypeInfo.GetNames(funcDesc.memid, funcDesc.cParams + 1);
            for (int i = 0; i < funcDesc.cParams; ++i)
            {
                ElemDesc paramElemDesc = funcDesc.GetElemDesc(i);

                typeString =
                    (new TlbType2String(interfaceTypeInfo, paramElemDesc.tdesc)).GetTypeString();

                //string signatureName = signatureNames[i + 1];
                //if (signatureName.Trim().Equals(""))
                //    signatureName = "_unnamed_arg_" + paramIndex;
                SignatureInfoMatchTarget paramSignatureInfo = new SignatureInfoMatchTarget(
                    interfaceTypeInfo, funcIndex, paramElemDesc, paramIndex);
                TreeNode paramTreeNode = new TreeNode();
                paramTreeNode.Text = typeString + "  " + paramSignatureInfo.Name +
                    ": " + paramSignatureInfo.Type;
                ++paramIndex;
                paramTreeNode.Tag = paramSignatureInfo;
                SetTlbTreeNodeImage(paramTreeNode);
                parentTreeNode.Nodes.Add(paramTreeNode);
            }
        }
예제 #5
0
        private static void GetTypeFromConvertToAction(SignatureInfoMatchTarget target,
            ConvertToAction convertToAction, ConverterInfo converterInfo, TypeInfo typeInfo,
            TypeDesc typeDesc, out Type typeReturn, out CustomAttributeBuilder customAttribute,
            out ParameterAttributes fixedParameterAttributes)
        {
            typeReturn = null;
            customAttribute = null;
            fixedParameterAttributes = ParameterAttributes.None;
            ParameterDirection direction =
                ConvertToActionConstants.GetParameterDirection(convertToAction.Direction);
            switch (direction)
            {
                case ParameterDirection.IN:
                    fixedParameterAttributes |= ParameterAttributes.In;
                    break;
                case ParameterDirection.OUT:
                    fixedParameterAttributes |= ParameterAttributes.Out;
                    break;
                case ParameterDirection.INOUT:
                    fixedParameterAttributes |= ParameterAttributes.In;
                    fixedParameterAttributes |= ParameterAttributes.Out;
                    break;
            }
            Dictionary<string, string> attributePairDictionary =
                ConvertToAction.GetConvertToAttributeDictionary(convertToAction.Attributes);
            ManagedTypeConvertTo managedType =
                ConvertToActionConstants.GetManagedTypeConvertTo(convertToAction.ManagedTypeConvertTo);
            UnmanagedType marshalAs =
                ConvertToActionConstants.GetMarshalAs(convertToAction.UnmanagedTypeMarshalAs);

            switch (managedType)
            {
                case ManagedTypeConvertTo.LPARRAY:
                    if ((VarEnum)typeDesc.vt == VarEnum.VT_CARRAY || (VarEnum)typeDesc.vt == VarEnum.VT_PTR)
                    {
                        TypeConverter elemTypeConverter = new TypeConverter(converterInfo, typeInfo,
                            typeDesc.lptdesc, ConversionType.Element);
                        Type elemType = elemTypeConverter.ConvertedType;
                        typeReturn = elemType.MakeArrayType();
                        if (attributePairDictionary.ContainsKey(ConvertToActionDef.SizeConst))
                        {
                            customAttribute = CustomAttributeHelper.GetBuilderForMarshalAsConstArray(UnmanagedType.LPArray,
                                Int32.Parse(attributePairDictionary[ConvertToActionDef.SizeConst].ToString()));
                        }
                        else if (attributePairDictionary.ContainsKey(ConvertToActionDef.SizeParamIndex))
                        {
                            customAttribute = CustomAttributeHelper.GetBuilderForMarshalAsConstArrayBySizeParamIndex(
                                UnmanagedType.LPArray,
                                Int16.Parse(attributePairDictionary[ConvertToActionDef.SizeParamIndex].ToString()));
                        }
                        else if (attributePairDictionary.ContainsKey(ConvertToActionDef.SizeParamIndexOffset))
                        {
                            customAttribute = CustomAttributeHelper.GetBuilderForMarshalAsConstArrayBySizeParamIndex(
                                UnmanagedType.LPArray,
                                (short)((target.NativeParameterIndex) - 1 +
                                         Int16.Parse(attributePairDictionary[ConvertToActionDef.SizeParamIndexOffset].ToString())));
                        }
                        else
                        {
                            customAttribute = CustomAttributeHelper.GetBuilderForMarshalAs(UnmanagedType.LPArray);
                        }
                    }
                    else
                    {
                        string targetTypeString = new TlbType2String(typeInfo, typeDesc).GetTypeString();
                        throw new TlbImpGeneralException(Resource.FormatString("Err_ConvertNonArrayToArray", targetTypeString),
                            ErrorCode.Err_ConvertNonArrayToArray);
                    }
                    break;
                case ManagedTypeConvertTo.DECIMAL:
                    typeReturn = typeof(Decimal);
                    if (marshalAs != (UnmanagedType)(-1))
                        customAttribute = CustomAttributeHelper.GetBuilderForMarshalAs(marshalAs);
                    break;
                case ManagedTypeConvertTo.INT:
                    typeReturn = typeof(int);
                    if (marshalAs != (UnmanagedType)(-1))
                        customAttribute = CustomAttributeHelper.GetBuilderForMarshalAs(marshalAs);
                    break;
                case ManagedTypeConvertTo.OBJECT:
                    typeReturn = typeof(object);
                    if (marshalAs != (UnmanagedType)(-1))
                        customAttribute = CustomAttributeHelper.GetBuilderForMarshalAs(marshalAs);
                    break;
                case ManagedTypeConvertTo.STRING:
                    typeReturn = typeof(string);
                    if (marshalAs != (UnmanagedType)(-1))
                        customAttribute = CustomAttributeHelper.GetBuilderForMarshalAs(marshalAs);
                    break;
                case ManagedTypeConvertTo.STRINGBUILDER:
                    typeReturn = typeof(StringBuilder);
                    if (marshalAs != (UnmanagedType)(-1))
                        customAttribute = CustomAttributeHelper.GetBuilderForMarshalAs(marshalAs);
                    break;
            }
            if (convertToAction.ByRef)
            {
                typeReturn = typeReturn.MakeByRefType();
            }
        }
예제 #6
0
 private static void GetRuledReturnTypeConverter(InterfaceInfo info,
     InterfaceMemberInfo memInfo, FuncDesc func, out TypeConverter convertToReturnConverter)
 {
     convertToReturnConverter = null;
     Rule convertToRule = null;
     if (memInfo.Index != -1)
     {
         // Is not event delegate.
         SignatureInfoMatchTarget returnTarget = new SignatureInfoMatchTarget(
                     info.RefTypeInfo, memInfo.Index, func.elemdescFunc, 0);
         if (info.ConverterInfo.Settings.m_ruleSet != null)
         {
             ICategory signatureCategory = SignatureCategory.GetInstance();
             AbstractActionManager actionManager = RuleEngine.GetActionManager();
             List<Rule> convertToRules = info.ConverterInfo.Settings.m_ruleSet.GetRule(
                 signatureCategory, ConvertToActionDef.GetInstance(), returnTarget);
             if (convertToRules.Count != 0)
             {
                 if (convertToRules.Count > 1)
                 {
                     Output.WriteWarning(
                         Resource.FormatString("Wrn_RuleMultipleMatch",
                                               ConvertToActionDef.GetInstance().GetActionName()),
                         WarningCode.Wrn_RuleMultipleMatch);
                 }
                 convertToRule = convertToRules[convertToRules.Count - 1];
             }
         }
         if (convertToRule != null)
         {
             var convertToAction = convertToRule.Action as ConvertToAction;
             Type typeReturn;
             CustomAttributeBuilder customAttribute;
             ParameterAttributes fixedParameterAttributes;
             GetTypeFromConvertToAction(returnTarget, convertToAction, info.ConverterInfo,
                 info.RefTypeInfo, func.elemdescFunc.tdesc, out typeReturn, out customAttribute,
                 out fixedParameterAttributes);
             convertToReturnConverter =
                 new TypeConverter(typeReturn, customAttribute, fixedParameterAttributes);
         }
     }
 }
예제 #7
0
        private static void GetRuledParameterTypeConverters(InterfaceInfo info, InterfaceMemberInfo memInfo,
            FuncDesc func, out List<TypeConverter> convertToParameterConverterList)
        {
            int cParams = func.cParams;
            convertToParameterConverterList = new List<TypeConverter>();

            short n;
            for (n = 0; n < cParams; ++n)
            {
                ElemDesc elem = func.GetElemDesc(n);
                ParamDesc paramDesc = elem.paramdesc;

                // "ConvertTo" for basic types and array
                // Rule Engine
                Rule convertToRule = null;
                if (memInfo.Index != -1)
                {
                    // Is not event delegate.
                    SignatureInfoMatchTarget target = new SignatureInfoMatchTarget(
                            info.RefTypeInfo, memInfo.Index, elem, n + 1);
                    if (info.ConverterInfo.Settings.m_ruleSet != null)
                    {
                        ICategory signatureCategory = SignatureCategory.GetInstance();
                        AbstractActionManager actionManager = RuleEngine.GetActionManager();
                        List<Rule> convertToRules = info.ConverterInfo.Settings.m_ruleSet.GetRule(
                            signatureCategory, ConvertToActionDef.GetInstance(), target);
                        if (convertToRules.Count != 0)
                        {
                            if (convertToRules.Count > 1)
                            {
                                Output.WriteWarning(
                                    Resource.FormatString("Wrn_RuleMultipleMatch",
                                                          ConvertToActionDef.GetInstance().GetActionName()),
                                    WarningCode.Wrn_RuleMultipleMatch);
                            }
                            convertToRule = convertToRules[convertToRules.Count - 1];
                        }
                    }
                    if (convertToRule != null)
                    {
                        var convertToAction = convertToRule.Action as ConvertToAction;
                        Type typeReturn;
                        CustomAttributeBuilder customAttribute;
                        ParameterAttributes fixedParameterAttributes;
                        GetTypeFromConvertToAction(target, convertToAction, info.ConverterInfo,
                            info.RefTypeInfo, elem.tdesc, out typeReturn, out customAttribute,
                            out fixedParameterAttributes);
                        convertToParameterConverterList.Add(
                            new TypeConverter(typeReturn, customAttribute, fixedParameterAttributes));
                    }
                    else
                    {
                        convertToParameterConverterList.Add(null);
                    }
                }
                else
                {
                    convertToParameterConverterList.Add(null);
                }
            }
        }