Discussion :

[mony84]

Bonjour,
j'ai une fonction qui renvoie un HRESULT et j'ai une condition :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
if (SUCCEEDED(hr)){
......
}

ma fonction ne renvoie pas un S_OK,

j'ai besoin donc de savoir le code d'erreur qu'elle renvoie.

[mony84]

la valeur renvoyée est égale à -2147467259!!!

[Spout]

Salut,

Quelle est la fonction utilisée?
(La prochaine fois, place le code directement dans ton post de manière à avoir des réponses plus rapidement )

[mony84]

voici le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
#include <windows.h>
#include <objbase.h>
#include <stdio.h>
#include "model/model.h"
 
 
 
int main (int argc , char **argv){
 
HRESULT			hr  ;
HRESULT			hr1 ;
HRESULT			hr2 ;
HRESULT			hr3 ;
 
ISIMSATSMIScriptCommands *HumanObject =NULL;
ISIMSATSMIScriptCommandsVtbl *lpVtbl_1=NULL;
 
FILE* fp;
 
long *pHead=malloc(sizeof(long));
long *pHair=malloc(sizeof(long));
VARIANT *pvalue=malloc(sizeof(VARIANT));
 
 
if (!CoInitialize(0))
	{
 
hr=CoGetObject(L"C:\\Simulator\\Simulator_System_Files\\SIM.simsat!Human",
					NULL,
					&IID_ISIMSATSMIScriptCommands, 
					&humanObject);
 
lpVtbl_1=humanObject->lpVtbl;
 
 
hr1=lpVtbl_1->GetObjectID(humanObject,"Head",pHead);//__obj__ID
hr2=lpVtbl_1->GetDataID(humanObject,pHead,"NumHairs",pHair);//__data__ID
 
 
//la source du problème
hr3=lpVtbl_1->GetDataValue(humanObject,pHead,pHair,pvalue);
 
 
 
free(pHead);
free(pHair);
free(pvalue);
 
	}
 
 
 
}

[Spout]

Il faut que tu regardes si la valeur retournée par la fonction correspond à un code de retour spécifique de GetDataValue() (je n'ai pas pu trouver de doc sur cette fonction).

[mony84]

Merci spoutspout,
le problème c'est que je n'ai que le fichier d'entête (et un fichier de description .idl )

et dedans il n'y a pas de documentation sur les valeurs de retour:

la déclaration de la fonction est la suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
 
        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *GetDataValue )( 
            ISIMSATSMIScriptCommands * This,
            /* [in] */ LONG ObjectID,
            /* [in] */ LONG DataID,
            /* [retval][out] */ VARIANT *pValue);

[Spout]

Comment tu peux savoir alors que c'est un S_OK que tu attends? Si ça se trouve, la valeur reçue est tout à fait bonne...

[mony84]

une bonne question

je connais la valeur de *pvalue

elle vaut 10000
et c'est un unsigned int

la fonction récupère la valeur dans un VARIANT et je ne sais pas comment manipuler ce type propre à COM, pour extraire la valeur de la variable.

la fonction récupère tout type de données (booléen , int , double ...) et le met dans un VARIANT.

[mony84]

sur msdn, j'ai trouvé la définition du type VARIANT défintion de VARIANT

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
typedef struct tagVARIANT VARIANT;
typedef struct tagVARIANT VARIANTARG;
struct tagVARIANT
    {
    union 
        {
        struct __tagVARIANT
            {
            VARTYPE vt;
            WORD wReserved1;
            WORD wReserved2;
            WORD wReserved3;
            union 
                {
                LONGLONG llVal;
                LONG lVal;
                BYTE bVal;
                SHORT iVal;
                FLOAT fltVal;
                DOUBLE dblVal;
                VARIANT_BOOL boolVal;
                _VARIANT_BOOL bool;
                SCODE scode;
                CY cyVal;
                DATE date;
                BSTR bstrVal;
                IUnknown *punkVal;
                IDispatch *pdispVal;
                SAFEARRAY *parray;
                BYTE *pbVal;
                SHORT *piVal;
                LONG *plVal;
                LONGLONG *pllVal;
                FLOAT *pfltVal;
                DOUBLE *pdblVal;
                VARIANT_BOOL *pboolVal;
                _VARIANT_BOOL *pbool;
                SCODE *pscode;
                CY *pcyVal;
                DATE *pdate;
                BSTR *pbstrVal;
                IUnknown **ppunkVal;
                IDispatch **ppdispVal;
                SAFEARRAY **pparray;
                VARIANT *pvarVal;
                PVOID byref;
                CHAR cVal;
                USHORT uiVal;
                ULONG ulVal;
                ULONGLONG ullVal;
                INT intVal;
                UINT uintVal;
                DECIMAL *pdecVal;
                CHAR *pcVal;
                USHORT *puiVal;
                ULONG *pulVal;
                ULONGLONG *pullVal;
                INT *pintVal;
                UINT *puintVal;
                struct __tagBRECORD
                    {
                    PVOID pvRecord;
                    IRecordInfo *pRecInfo;
                    }    __VARIANT_NAME_4;
                }    __VARIANT_NAME_3;
            }    __VARIANT_NAME_2;
        DECIMAL decVal;
        }    __VARIANT_NAME_1;
struct tagVARIANT  
   {
    union 
       {
       struct __tagVARIANT
       {
          VARTYPE vt;
          WORD wReserved1;
          WORD wReserved2;
          WORD wReserved3;
   union {
      LONGLONG                llval;             // VT_I8. 
      LONG                    lVal;              // VT_I4.
      BYTE                    bVal;              // VT_UI1.
      SHORT                   iVal;              // VT_I2.
      FLOAT                   fltVal;            // VT_R4.
      DOUBLE                  dblVal;            // VT_R8.
      VARIANT_BOOL            boolVal;           // VT_BOOL.
      _VARIANT_BOOL           bool;
      SCODE                   scode;             // VT_ERROR.
      CY                      cyVal;             // VT_CY.
      DATE                    date;              // VT_DATE.
      BSTR                    bstrVal;           // VT_BSTR.
      IUnknown                * punkVal;         // VT_UNKNOWN.
      IDispatch               * pdispVal;        // VT_DISPATCH.
      SAFEARRAY               * parray;          // VT_ARRAY|*.
      BYTE                    * pbVal;           // VT_BYREF|VT_UI1.
      SHORT                   * piVal;           // VT_BYREF|VT_I2.
      LONG                    * plVal;           // VT_BYREF|VT_I4.
      LONGLONG                * pllVal;          // VT_BYREF|VT_I8.
      FLOAT                   * pfltVal;         // VT_BYREF|VT_R4.
      DOUBLE                  * pdblVal;         // VT_BYREF|VT_R8.
      VARIANT_BOOL            * pboolVal;        // VT_BYREF|VT_BOOL.
      _VARIANT_BOOL           * pbool;
      SCODE                   * pscode;          // VT_BYREF|VT_ERROR.
      CY                      * pcyVal;          // VT_BYREF|VT_CY.
      DATE                    * pdate;           // VT_BYREF|VT_DATE.
      BSTR                    * pbstrVal;        // VT_BYREF|VT_BSTR.
      IUnknown                ** ppunkVal;       // VT_BYREF|VT_UNKNOWN.
      IDispatch               ** ppdispVal;      // VT_BYREF|VT_DISPATCH.
      SAFEARRAY               ** pparray;        // VT_BYREF|VT_ARRAY.
      VARIANT                 * pvarVal;         // VT_BYREF|VT_VARIANT.
      PVOID                   * byref;           // Generic ByRef.
      CHAR                    cVal;              // VT_I1.
      USHORT                  uiVal;             // VT_UI2.
      ULONG                   ulVal;             // VT_UI4.
      ULONGLONG               ullVal;            // VT_UI8.
      INT                     intVal;            // VT_INT.
      UINT                    uintVal;           // VT_UINT.
      DECIMAL                 * pdecVal          // VT_BYREF|VT_DECIMAL.
      CHAR                    * pcVal;           // VT_BYREF|VT_I1.
      USHORT                  * puiVal;          // VT_BYREF|VT_UI2.
      ULONG                   * pulVal;          // VT_BYREF|VT_UI4.
      ULONGLONG               * pullVal;         // VT_BYREF|VT_UI8.
      INT                     * pintVal;         // VT_BYREF|VT_INT.
      UINT                    * puintVal;        // VT_BYREF|VT_UINT.
      struct __tagBRECORD
      {
      PVOID                   pvRecord;
      IRecordInfo             *pRecInfo;
      }    __VARIANT_NAME_4;
   }    __VARIANT_NAME_3;
  }    __VARIANT_NAME_2;
  DECIMAL decVal;
}    __VARIANT_NAME_1;
 
   };
};

[Médinoc]

Sachant que tu as des fonctions comme VariantInit() et VariantClear(), et des macros comme V_VT(), V_I4(), V_BSTR(), etc.

Pour le HRESULT, il est possible de le convertir en erreur Win32 si sa Facility est la bonne. Pour ça, il suffit de comparer HRESULT_FACILITY(hr) à FACILITY_WIN32, puis de lire HRESULT_CODE(hr) si c'est égal...
Avec ça, tu peux utiliser une fonction comme FormatMessage() pour avoir plus d'infos.

Ensuite, pour les HRESULT qui ne sont pas Win32, le mieux est de regarder sa valeur en hexadécimal (dans le cas de ton premier post, 0x80004005). Une petite recherche dans les headers Windows indique que cette valeur correspond à E_FAIL...

[mony84]

Merci Médinoc,

j'ai utilisé la macro V_UINT(pvalue) pour extraire la donnée puisque c'est un unsigned int que je veux récupérer du VARIANT

j'ai eu une valeur "bidon"

j'ai effectué un test sur la valeur de pvalue->vt pour savoir ce que la variable de type VARIANT contient et à ma grande surprise la fonction revoie un BSTR!!!

quelqu'un peut m'aider pour afficher un BSTR?

Merci

[Médinoc]

Une BSTR, c'est juste une chaîne unicode avec quelques particularités.
Tant que tu ne la modifies pas, tu peux tout-à-fait la passer à n'importe quelle fonction à laquelle tu passerait un LPCWSTR.

Tu peux donc l'afficher avec wprintf() ou MessageBoxW(), par exemple.

[mony84]

merci Médinoc et spoutspout,

je n'arrive pas à avoir des valeurs "logiques" mais ce qui importe c'est que j'ai appris à manipuler les types BSTR et VARIANT