1 | // Licensed to the .NET Foundation under one or more agreements. |
2 | // The .NET Foundation licenses this file to you under the MIT license. |
3 | // See the LICENSE file in the project root for more information. |
4 | //***************************************************************************** |
5 | // TargetTypes.cpp |
6 | // |
7 | |
8 | // |
9 | //***************************************************************************** |
10 | |
11 | #include "stdafx.h" |
12 | #include "targettypes.h" |
13 | |
14 | |
15 | Target_CMiniMdSchemaBase::Target_CMiniMdSchemaBase() : |
16 | m_ulReserved(0), |
17 | m_major(0), |
18 | m_minor(0), |
19 | m_heaps(0), |
20 | m_rid(0), |
21 | m_maskvalid(0), |
22 | m_sorted(0) |
23 | {} |
24 | |
25 | HRESULT Target_CMiniMdSchemaBase::ReadFrom(DataTargetReader & reader) |
26 | { |
27 | HRESULT hr = S_OK; |
28 | reader.Align(8); // this type needs 8 byte alignment from m_maskvalid |
29 | IfFailRet(reader.Read32(&m_ulReserved)); |
30 | IfFailRet(reader.Read8(&m_major)); |
31 | IfFailRet(reader.Read8(&m_minor)); |
32 | IfFailRet(reader.Read8(&m_heaps)); |
33 | IfFailRet(reader.Read8(&m_rid)); |
34 | IfFailRet(reader.Read64(&m_maskvalid)); |
35 | IfFailRet(reader.Read64(&m_sorted)); |
36 | return S_OK; |
37 | } |
38 | |
39 | Target_CMiniMdSchema::Target_CMiniMdSchema() : |
40 | m_ulExtra(0) |
41 | { |
42 | memset(&m_cRecs, 0, TBL_COUNT*sizeof(ULONG32)); |
43 | } |
44 | |
45 | HRESULT Target_CMiniMdSchema::ReadFrom(DataTargetReader & reader) |
46 | { |
47 | HRESULT hr = S_OK; |
48 | IfFailRet(Target_CMiniMdSchemaBase::ReadFrom(reader)); |
49 | reader.AlignBase(); |
50 | for (int i = 0; i < TBL_COUNT; i++) |
51 | IfFailRet(reader.Read32(&(m_cRecs[i]))); |
52 | IfFailRet(reader.Read32(&m_ulExtra)); |
53 | return S_OK; |
54 | } |
55 | |
56 | Target_CMiniColDef::Target_CMiniColDef() : |
57 | m_Type(0), |
58 | m_oColumn(0), |
59 | m_cbColumn(0) |
60 | { |
61 | } |
62 | |
63 | HRESULT Target_CMiniColDef::ReadFrom(DataTargetReader & reader) |
64 | { |
65 | HRESULT hr = S_OK; |
66 | IfFailRet(reader.Read8(&m_Type)); |
67 | IfFailRet(reader.Read8(&m_oColumn)); |
68 | IfFailRet(reader.Read8(&m_cbColumn)); |
69 | return S_OK; |
70 | } |
71 | |
72 | Target_CMiniTableDef::Target_CMiniTableDef() : |
73 | m_pColDefs(NULL), |
74 | m_cCols(0), |
75 | m_iKey(0), |
76 | m_cbRec(0) |
77 | {} |
78 | |
79 | HRESULT Target_CMiniTableDef::ReadFrom(DataTargetReader & reader) |
80 | { |
81 | HRESULT hr = S_OK; |
82 | CORDB_ADDRESS pColDefs = NULL; |
83 | IfFailRet(reader.ReadPointer(&pColDefs)); |
84 | IfFailRet(reader.Read8(&m_cCols)); |
85 | IfFailRet(reader.Read8(&m_iKey)); |
86 | IfFailRet(reader.Read8(&m_cbRec)); |
87 | |
88 | // sanity check before allocating |
89 | if (m_cCols > 100) |
90 | return CLDB_E_FILE_CORRUPT; |
91 | m_pColDefs = new (nothrow) Target_CMiniColDef[m_cCols]; |
92 | if (m_pColDefs == NULL) |
93 | return E_OUTOFMEMORY; |
94 | DataTargetReader colsReader = reader.CreateReaderAt(pColDefs); |
95 | for (int i = 0; i < m_cCols; i++) |
96 | { |
97 | IfFailRet(colsReader.Read(&m_pColDefs[i])); |
98 | } |
99 | |
100 | return S_OK; |
101 | } |
102 | |
103 | Target_CMiniMdBase::Target_CMiniMdBase() : |
104 | m_TblCount(0), |
105 | m_fVerifiedByTrustedSource(FALSE), |
106 | m_iStringsMask(0), |
107 | m_iGuidsMask(0), |
108 | m_iBlobsMask(0) |
109 | {} |
110 | |
111 | HRESULT Target_CMiniMdBase::ReadFrom(DataTargetReader & reader) |
112 | { |
113 | HRESULT hr = S_OK; |
114 | IfFailRet(reader.SkipPointer()); // vtable |
115 | IfFailRet(reader.Read(&m_Schema)); |
116 | IfFailRet(reader.Read32(&m_TblCount)); |
117 | IfFailRet(reader.Read32((ULONG32*)&m_fVerifiedByTrustedSource)); |
118 | for (int i = 0; i < TBL_COUNT; i++) |
119 | IfFailRet(reader.Read(&(m_TableDefs[i]))); |
120 | IfFailRet(reader.Read32(&m_iStringsMask)); |
121 | IfFailRet(reader.Read32(&m_iGuidsMask)); |
122 | IfFailRet(reader.Read32(&m_iBlobsMask)); |
123 | return S_OK; |
124 | } |
125 | |
126 | Target_MapSHash::Target_MapSHash() : |
127 | m_table(0), |
128 | m_tableSize(0), |
129 | m_tableCount(0), |
130 | m_tableOccupied(0), |
131 | m_tableMax(0) |
132 | {} |
133 | |
134 | HRESULT Target_MapSHash::ReadFrom(DataTargetReader & reader) |
135 | { |
136 | HRESULT hr = S_OK; |
137 | // Only the Windows MSVC compiler does this; not clang on Linux |
138 | #ifdef _MSC_VER |
139 | IfFailRet(reader.Skip8()); // this byte gets used by the base class even though it has no members |
140 | // I'm guessing this is so the 2nd base class (noncopyable) doesn't start at the same |
141 | // location, but I can't be sure. Whatever the cause, the layout skips a byte. |
142 | #endif // _MSC_VER |
143 | IfFailRet(reader.ReadPointer(&m_table)); |
144 | IfFailRet(reader.Read32(&m_tableSize)); |
145 | IfFailRet(reader.Read32(&m_tableCount)); |
146 | IfFailRet(reader.Read32(&m_tableOccupied)); |
147 | IfFailRet(reader.Read32(&m_tableMax)); |
148 | return S_OK; |
149 | } |
150 | |
151 | |
152 | |
153 | Target_StgPoolSeg::Target_StgPoolSeg() : |
154 | m_pSegData(0), |
155 | m_pNextSeg(0), |
156 | m_cbSegSize(0), |
157 | m_cbSegNext(0) |
158 | {} |
159 | |
160 | HRESULT Target_StgPoolSeg::ReadFrom(DataTargetReader & reader) |
161 | { |
162 | HRESULT hr = S_OK; |
163 | IfFailRet(reader.ReadPointer(&m_pSegData)); |
164 | IfFailRet(reader.ReadPointer(&m_pNextSeg)); |
165 | IfFailRet(reader.Read32(&m_cbSegSize)); |
166 | IfFailRet(reader.Read32(&m_cbSegNext)); |
167 | return S_OK; |
168 | } |
169 | |
170 | |
171 | Target_CChainedHash::Target_CChainedHash() : |
172 | m_rgData(0), |
173 | m_iBuckets(0), |
174 | m_iSize(0), |
175 | m_iCount(0), |
176 | m_iMaxChain(0), |
177 | m_iFree(0) |
178 | {} |
179 | |
180 | HRESULT Target_CChainedHash::ReadFrom(DataTargetReader & reader) |
181 | { |
182 | HRESULT hr = S_OK; |
183 | IfFailRet(reader.SkipPointer()); // __vfptr |
184 | IfFailRet(reader.ReadPointer(&m_rgData)); |
185 | IfFailRet(reader.Read32(&m_iBuckets)); |
186 | IfFailRet(reader.Read32(&m_iSize)); |
187 | IfFailRet(reader.Read32(&m_iCount)); |
188 | IfFailRet(reader.Read32(&m_iMaxChain)); |
189 | IfFailRet(reader.Read32(&m_iFree)); |
190 | return S_OK; |
191 | } |
192 | |
193 | Target_CStringPoolHash::Target_CStringPoolHash() : |
194 | m_Pool(0) |
195 | {} |
196 | |
197 | HRESULT Target_CStringPoolHash::ReadFrom(DataTargetReader & reader) |
198 | { |
199 | HRESULT hr = S_OK; |
200 | IfFailRet(Target_CChainedHash::ReadFrom(reader)); |
201 | reader.AlignBase(); |
202 | IfFailRet(reader.ReadPointer(&m_Pool)); |
203 | return S_OK; |
204 | } |
205 | |
206 | Target_CBlobPoolHash::Target_CBlobPoolHash() : |
207 | m_Pool(0) |
208 | {} |
209 | |
210 | HRESULT Target_CBlobPoolHash::ReadFrom(DataTargetReader & reader) |
211 | { |
212 | HRESULT hr = S_OK; |
213 | IfFailRet(Target_CChainedHash::ReadFrom(reader)); |
214 | reader.AlignBase(); |
215 | IfFailRet(reader.ReadPointer(&m_Pool)); |
216 | return S_OK; |
217 | } |
218 | |
219 | |
220 | Target_CGuidPoolHash::Target_CGuidPoolHash() : |
221 | m_Pool(0) |
222 | { } |
223 | |
224 | HRESULT Target_CGuidPoolHash::ReadFrom(DataTargetReader & reader) |
225 | { |
226 | HRESULT hr = S_OK; |
227 | IfFailRet(Target_CChainedHash::ReadFrom(reader)); |
228 | reader.AlignBase(); |
229 | IfFailRet(reader.ReadPointer(&m_Pool)); |
230 | return S_OK; |
231 | } |
232 | |
233 | Target_HotHeap::Target_HotHeap() : |
234 | m_pHotHeapHeader(0) |
235 | {} |
236 | |
237 | HRESULT Target_HotHeap::ReadFrom(DataTargetReader & reader) |
238 | { |
239 | HRESULT hr = S_OK; |
240 | IfFailRet(reader.ReadPointer(&m_pHotHeapHeader)); |
241 | return S_OK; |
242 | } |
243 | |
244 | HRESULT Target_StgPoolReadOnly::ReadFrom(DataTargetReader & reader) |
245 | { |
246 | HRESULT hr = S_OK; |
247 | IfFailRet(reader.SkipPointer()); // __vfptr |
248 | IfFailRet(Target_StgPoolSeg::ReadFrom(reader)); |
249 | reader.AlignBase(); |
250 | IfFailRet(reader.Read(&m_HotHeap)); |
251 | return S_OK; |
252 | } |
253 | |
254 | Target_StgPool::Target_StgPool() : |
255 | m_ulGrowInc(0), |
256 | m_pCurSeg(0), |
257 | m_cbCurSegOffset(0), |
258 | m_bFree(FALSE), |
259 | m_bReadOnly(FALSE), |
260 | m_nVariableAlignmentMask(0), |
261 | m_cbStartOffsetOfEdit(0), |
262 | m_fValidOffsetOfEdit(FALSE) |
263 | {} |
264 | |
265 | HRESULT Target_StgPool::ReadFrom(DataTargetReader & reader) |
266 | { |
267 | HRESULT hr = S_OK; |
268 | IfFailRet(Target_StgPoolReadOnly::ReadFrom(reader)); |
269 | reader.AlignBase(); |
270 | IfFailRet(reader.Read32(&m_ulGrowInc)); |
271 | IfFailRet(reader.ReadPointer(&m_pCurSeg)); |
272 | IfFailRet(reader.Read32(&m_cbCurSegOffset)); |
273 | ULONG32 bitField; |
274 | IfFailRet(reader.Read32(&bitField)); |
275 | m_bFree = (bitField & 0x1) != 0; |
276 | m_bReadOnly = (bitField & 0x2) != 0; |
277 | IfFailRet(reader.Read32(&m_nVariableAlignmentMask)); |
278 | IfFailRet(reader.Read32(&m_cbStartOffsetOfEdit)); |
279 | IfFailRet(reader.Read8((BYTE*)&m_fValidOffsetOfEdit)); |
280 | return S_OK; |
281 | } |
282 | |
283 | HRESULT Target_StgBlobPool::ReadFrom(DataTargetReader & reader) |
284 | { |
285 | HRESULT hr = S_OK; |
286 | IfFailRet(Target_StgPool::ReadFrom(reader)); |
287 | reader.AlignBase(); |
288 | IfFailRet(reader.Read(&m_Hash)); |
289 | return S_OK; |
290 | } |
291 | |
292 | Target_StgStringPool::Target_StgStringPool() : |
293 | m_bHash(FALSE) |
294 | { |
295 | } |
296 | |
297 | HRESULT Target_StgStringPool::ReadFrom(DataTargetReader & reader) |
298 | { |
299 | HRESULT hr = S_OK; |
300 | IfFailRet(Target_StgPool::ReadFrom(reader)); |
301 | reader.AlignBase(); |
302 | IfFailRet(reader.Read(&m_Hash)); |
303 | IfFailRet(reader.Read8((BYTE*)&m_bHash)); |
304 | return S_OK; |
305 | } |
306 | |
307 | Target_StgGuidPool::Target_StgGuidPool() : |
308 | m_bHash(FALSE) |
309 | {} |
310 | |
311 | HRESULT Target_StgGuidPool::ReadFrom(DataTargetReader & reader) |
312 | { |
313 | HRESULT hr = S_OK; |
314 | IfFailRet(Target_StgPool::ReadFrom(reader)); |
315 | reader.AlignBase(); |
316 | IfFailRet(reader.Read(&m_Hash)); |
317 | IfFailRet(reader.Read8((BYTE*)&m_bHash)); |
318 | return S_OK; |
319 | } |
320 | |
321 | Target_RecordPool::Target_RecordPool() : |
322 | m_cbRec(0) |
323 | {} |
324 | |
325 | HRESULT Target_RecordPool::ReadFrom(DataTargetReader & reader) |
326 | { |
327 | HRESULT hr = S_OK; |
328 | IfFailRet(Target_StgPool::ReadFrom(reader)); |
329 | reader.AlignBase(); |
330 | IfFailRet(reader.Read32(&m_cbRec)); |
331 | return S_OK; |
332 | } |
333 | |
334 | Target_OptionValue::Target_OptionValue() : |
335 | m_DupCheck(0), |
336 | m_RefToDefCheck(0), |
337 | m_NotifyRemap(0), |
338 | m_UpdateMode(0), |
339 | m_ErrorIfEmitOutOfOrder(0), |
340 | m_ThreadSafetyOptions(0), |
341 | m_ImportOption(0), |
342 | m_LinkerOption(0), |
343 | m_GenerateTCEAdapters(0), |
344 | m_RuntimeVersion(0), |
345 | m_MetadataVersion(0), |
346 | m_MergeOptions(0), |
347 | m_InitialSize(0), |
348 | m_LocalRefPreservation(0) |
349 | {} |
350 | |
351 | HRESULT Target_OptionValue::ReadFrom(DataTargetReader & reader) |
352 | { |
353 | HRESULT hr = S_OK; |
354 | IfFailRet(reader.Read32(&m_DupCheck)); |
355 | IfFailRet(reader.Read32(&m_RefToDefCheck)); |
356 | IfFailRet(reader.Read32(&m_NotifyRemap)); |
357 | IfFailRet(reader.Read32(&m_UpdateMode)); |
358 | IfFailRet(reader.Read32(&m_ErrorIfEmitOutOfOrder)); |
359 | IfFailRet(reader.Read32(&m_ThreadSafetyOptions)); |
360 | IfFailRet(reader.Read32(&m_ImportOption)); |
361 | IfFailRet(reader.Read32(&m_LinkerOption)); |
362 | IfFailRet(reader.Read32(&m_GenerateTCEAdapters)); |
363 | IfFailRet(reader.ReadPointer(&m_RuntimeVersion)); |
364 | IfFailRet(reader.Read32(&m_MetadataVersion)); |
365 | IfFailRet(reader.Read32(&m_MergeOptions)); |
366 | IfFailRet(reader.Read32(&m_InitialSize)); |
367 | IfFailRet(reader.Read32(&m_LocalRefPreservation)); |
368 | return S_OK; |
369 | } |
370 | |
371 | Target_CMiniMdRW::Target_CMiniMdRW() : |
372 | m_pMemberRefHash(0), |
373 | m_pMemberDefHash(0), |
374 | m_pNamedItemHash(0), |
375 | m_maxRid(0), |
376 | m_limRid(0), |
377 | m_maxIx(0), |
378 | m_limIx(0), |
379 | m_eGrow(0), |
380 | m_pHandler(0), |
381 | m_cbSaveSize(0), |
382 | m_fIsReadOnly(FALSE), |
383 | m_bPreSaveDone(FALSE), |
384 | m_bSaveCompressed(FALSE), |
385 | m_bPostGSSMod(FALSE), |
386 | m_pMethodMap(0), |
387 | m_pFieldMap(0), |
388 | m_pPropertyMap(0), |
389 | m_pEventMap(0), |
390 | m_pParamMap(0), |
391 | m_pFilterTable(0), |
392 | m_pHostFilter(0), |
393 | m_pTokenRemapManager(0), |
394 | dbg_m_pLock(0), |
395 | m_fMinimalDelta(FALSE), |
396 | m_rENCRecs(0) |
397 | { |
398 | memset(&m_pLookUpHashs, 0, TBL_COUNT*sizeof(CORDB_ADDRESS)); |
399 | memset(&m_pVS, 0, TBL_COUNT*sizeof(CORDB_ADDRESS)); |
400 | memset(&m_bSortable, 0, TBL_COUNT*sizeof(BOOL)); |
401 | } |
402 | |
403 | HRESULT Target_CMiniMdRW::ReadFrom(DataTargetReader & reader) |
404 | { |
405 | HRESULT hr = S_OK; |
406 | IfFailRet(Target_CMiniMdTemplate_CMiniMdRW::ReadFrom(reader)); |
407 | reader.AlignBase(); |
408 | IfFailRet(reader.ReadPointer(&m_pMemberRefHash)); |
409 | IfFailRet(reader.ReadPointer(&m_pMemberDefHash)); |
410 | for (int i = 0; i < TBL_COUNT; i++) |
411 | IfFailRet(reader.ReadPointer(&m_pLookUpHashs[i])); |
412 | IfFailRet(reader.Read(&m_StringPoolOffsetHash)); |
413 | IfFailRet(reader.ReadPointer(&m_pNamedItemHash)); |
414 | IfFailRet(reader.Read32(&m_maxRid)); |
415 | IfFailRet(reader.Read32(&m_limRid)); |
416 | IfFailRet(reader.Read32(&m_maxIx)); |
417 | IfFailRet(reader.Read32(&m_limIx)); |
418 | IfFailRet(reader.Read32(&m_eGrow)); |
419 | for (int i = 0; i < TBL_COUNT; i++) |
420 | IfFailRet(reader.Read(&m_Tables[i])); |
421 | for (int i = 0; i < TBL_COUNT; i++) |
422 | IfFailRet(reader.ReadPointer(&m_pVS[i])); |
423 | IfFailRet(reader.Read(&m_StringHeap)); |
424 | IfFailRet(reader.Read(&m_BlobHeap)); |
425 | IfFailRet(reader.Read(&m_UserStringHeap)); |
426 | IfFailRet(reader.Read(&m_GuidHeap)); |
427 | IfFailRet(reader.ReadPointer(&m_pHandler)); |
428 | IfFailRet(reader.Read32(&m_cbSaveSize)); |
429 | ULONG32 bitField; |
430 | IfFailRet(reader.Read32(&bitField)); |
431 | m_fIsReadOnly = (bitField & 0x1) != 0; |
432 | m_bPreSaveDone = (bitField & 0x2) != 0; |
433 | m_bSaveCompressed = (bitField & 0x4) != 0; |
434 | m_bPostGSSMod = (bitField & 0x8) != 0; |
435 | IfFailRet(reader.ReadPointer(&m_pMethodMap)); |
436 | IfFailRet(reader.ReadPointer(&m_pFieldMap)); |
437 | IfFailRet(reader.ReadPointer(&m_pPropertyMap)); |
438 | IfFailRet(reader.ReadPointer(&m_pEventMap)); |
439 | IfFailRet(reader.ReadPointer(&m_pParamMap)); |
440 | IfFailRet(reader.ReadPointer(&m_pFilterTable)); |
441 | IfFailRet(reader.ReadPointer(&m_pHostFilter)); |
442 | IfFailRet(reader.ReadPointer(&m_pTokenRemapManager)); |
443 | IfFailRet(reader.Read(&m_OptionValue)); |
444 | IfFailRet(reader.Read(&m_StartupSchema)); |
445 | for (int i = 0; i < TBL_COUNT; i++) |
446 | IfFailRet(reader.Read8((BYTE*)&m_bSortable[i])); |
447 | if (reader.IsDefined(1)) // replace this with DEFINE__DEBUG |
448 | { |
449 | IfFailRet(reader.ReadPointer(&dbg_m_pLock)); |
450 | } |
451 | IfFailRet(reader.Read8((BYTE*)&m_fMinimalDelta)); |
452 | IfFailRet(reader.ReadPointer(&m_rENCRecs)); |
453 | return S_OK; |
454 | } |
455 | |
456 | |
457 | |
458 | Target_CLiteWeightStgdb_CMiniMdRW::Target_CLiteWeightStgdb_CMiniMdRW() : |
459 | m_pvMd(0), |
460 | m_cbMd(0) |
461 | { |
462 | } |
463 | |
464 | HRESULT Target_CLiteWeightStgdb_CMiniMdRW::ReadFrom(DataTargetReader & reader) |
465 | { |
466 | HRESULT hr = S_OK; |
467 | IfFailRet(reader.Read(&m_MiniMd)); |
468 | IfFailRet(reader.ReadPointer(&m_pvMd)); |
469 | IfFailRet(reader.Read32(&m_cbMd)); |
470 | return S_OK; |
471 | } |
472 | |
473 | Target_CLiteWeightStgdbRW::Target_CLiteWeightStgdbRW() : |
474 | m_cbSaveSize(0), |
475 | m_bSaveCompressed(FALSE), |
476 | m_pImage(0), |
477 | m_dwImageSize(0), |
478 | m_dwPEKind(0), |
479 | m_dwMachine(0), |
480 | m_pStreamList(0), |
481 | m_pNextStgdb(0), |
482 | m_eFileType(0), |
483 | m_wszFileName(0), |
484 | m_dwDatabaseLFT(0), |
485 | m_dwDatabaseLFS(0) |
486 | {} |
487 | |
488 | HRESULT Target_CLiteWeightStgdbRW::ReadFrom(DataTargetReader & reader) |
489 | { |
490 | HRESULT hr = S_OK; |
491 | IfFailRet(Target_CLiteWeightStgdb_CMiniMdRW::ReadFrom(reader)); |
492 | reader.AlignBase(); |
493 | IfFailRet(reader.Read32(&m_cbSaveSize)); |
494 | IfFailRet(reader.Read8((BYTE*)&m_bSaveCompressed)); |
495 | IfFailRet(reader.ReadPointer(&m_pImage)); |
496 | IfFailRet(reader.Read32(&m_dwImageSize)); |
497 | IfFailRet(reader.Read32(&m_dwPEKind)); |
498 | IfFailRet(reader.Read32(&m_dwMachine)); |
499 | IfFailRet(reader.ReadPointer(&m_pStreamList)); |
500 | IfFailRet(reader.ReadPointer(&m_pNextStgdb)); |
501 | IfFailRet(reader.Read32(&m_eFileType)); |
502 | IfFailRet(reader.ReadPointer(&m_wszFileName)); |
503 | IfFailRet(reader.Read32(&m_dwDatabaseLFT)); |
504 | IfFailRet(reader.Read32(&m_dwDatabaseLFS)); |
505 | IfFailRet(reader.ReadPointer(&m_pStgIO)); |
506 | return S_OK; |
507 | } |
508 | |
509 | |
510 | |
511 | Target_MDInternalRW::Target_MDInternalRW() : |
512 | m_tdModule(0), |
513 | m_cRefs(0), |
514 | m_fOwnStgdb(FALSE), |
515 | m_pUnk(0), |
516 | m_pUserUnk(0), |
517 | m_pIMetaDataHelper(0), |
518 | m_pSemReadWrite(0), |
519 | m_fOwnSem(FALSE) |
520 | { |
521 | } |
522 | |
523 | HRESULT Target_MDInternalRW::ReadFrom(DataTargetReader & reader) |
524 | { |
525 | HRESULT hr = S_OK; |
526 | IfFailRet(reader.SkipPointer()); // IMDInternalImportENC vtable |
527 | IfFailRet(reader.SkipPointer()); // IMDCommon vtable |
528 | IfFailRet(reader.ReadPointer(&m_pStgdb)); |
529 | IfFailRet(reader.Read32(&m_tdModule)); |
530 | IfFailRet(reader.Read32(&m_cRefs)); |
531 | IfFailRet(reader.Read8((BYTE*)&m_fOwnStgdb)); |
532 | IfFailRet(reader.ReadPointer(&m_pUnk)); |
533 | IfFailRet(reader.ReadPointer(&m_pUserUnk)); |
534 | IfFailRet(reader.ReadPointer(&m_pIMetaDataHelper)); |
535 | IfFailRet(reader.ReadPointer(&m_pSemReadWrite)); |
536 | IfFailRet(reader.Read8((BYTE*)&m_fOwnSem)); |
537 | return S_OK; |
538 | } |
539 | |