lire un HRESULT

Version imprimable

27/08/2008, 17h18
mony84

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

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.
27/08/2008, 17h27
mony84

la valeur renvoyée est égale à -2147467259!!!
27/08/2008, 18h02
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 ;))

voici le code

Code:

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

28/08/2008, 12h56
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).

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:

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

28/08/2008, 13h34
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...
28/08/2008, 13h43
mony84

une bonne question :king:

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.

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

Code:

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

28/08/2008, 14h17
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...
28/08/2008, 16h56
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
28/08/2008, 17h00
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.
29/08/2008, 11h10
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