自学教程：C++ EngFreeMem函数代码示例

VOID DrvDisablePDEV(DHPDEV dhpdev){    PPDEV   ppdev;    ppdev = (PPDEV) dhpdev;    DISPDBG((2, "disabling PDEV/n"));    EngDeletePalette(devinfoVGA.hpalDefault);// Free the preallocated saved screen bits buffer, if there is one.    if (ppdev->pjPreallocSSBBuffer != NULL)    {        EngFreeMem(ppdev->pjPreallocSSBBuffer);    }// Free the conversion table buffer    if (ppdev->pucDIB4ToVGAConvBuffer != NULL)    {        EngFreeMem(ppdev->pucDIB4ToVGAConvBuffer);    }// Delete the PDEV    EngFreeMem(dhpdev);    DISPDBG((2, "disabled PDEV/n"));}

BOOLAPIENTRYFtfdUnloadFontFile(    IN ULONG_PTR iFile){    PFTFD_FILE pfile = (PFTFD_FILE)iFile;    ULONG i;    DbgPrint("FtfdUnloadFontFile()/n");    // HACK!!!    EngFreeMem(pfile->pvView);    /* Cleanup faces */    for (i = 0; i < pfile->cNumFaces; i++)    {        FT_Done_Face(pfile->aftface[i]);    }    /* Unmap the font file */    EngUnmapFontFileFD(pfile->iFile);    /* Free the memory that was allocated for the font */    EngFreeMem(pfile);    return TRUE;}

ULONG APIENTRYDrvGetModes(   IN HANDLE hDriver,   IN ULONG cjSize,   OUT DEVMODEW *pdm){   ULONG ModeCount;   ULONG ModeInfoSize;   PVIDEO_MODE_INFORMATION ModeInfo, ModeInfoPtr;   ULONG OutputSize;   ModeCount = GetAvailableModes(hDriver, &ModeInfo, &ModeInfoSize);   if (ModeCount == 0)   {      return 0;   }   if (pdm == NULL)   {      EngFreeMem(ModeInfo);      return ModeCount * sizeof(DEVMODEW);   }   /*    * Copy the information about supported modes into the output buffer.    */   OutputSize = 0;   ModeInfoPtr = ModeInfo;   while (ModeCount-- > 0)   {      if (ModeInfoPtr->Length == 0)      {         ModeInfoPtr = (PVIDEO_MODE_INFORMATION)(((ULONG_PTR)ModeInfoPtr) + ModeInfoSize);         continue;      }      memset(pdm, 0, sizeof(DEVMODEW));      memcpy(pdm->dmDeviceName, DEVICE_NAME, sizeof(DEVICE_NAME));      pdm->dmSpecVersion =      pdm->dmDriverVersion = DM_SPECVERSION;      pdm->dmSize = sizeof(DEVMODEW);      pdm->dmDriverExtra = 0;      pdm->dmBitsPerPel = ModeInfoPtr->NumberOfPlanes * ModeInfoPtr->BitsPerPlane;      pdm->dmPelsWidth = ModeInfoPtr->VisScreenWidth;      pdm->dmPelsHeight = ModeInfoPtr->VisScreenHeight;      pdm->dmDisplayFrequency = ModeInfoPtr->Frequency;      pdm->dmDisplayFlags = 0;      pdm->dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT |                      DM_DISPLAYFREQUENCY | DM_DISPLAYFLAGS;      ModeInfoPtr = (PVIDEO_MODE_INFORMATION)(((ULONG_PTR)ModeInfoPtr) + ModeInfoSize);      pdm = (LPDEVMODEW)(((ULONG_PTR)pdm) + sizeof(DEVMODEW));      OutputSize += sizeof(DEVMODEW);   }   EngFreeMem(ModeInfo);   return OutputSize;}

BOOLAPIENTRYEngFreeSectionMem(    IN PVOID pvSection OPTIONAL,    IN PVOID pvMappedBase OPTIONAL){    NTSTATUS Status;    PENGSECTION pSection = pvSection;    BOOL bResult = TRUE;    /* Did the caller give us a mapping base? */    if (pvMappedBase)    {        Status = MmUnmapViewInSessionSpace(pvMappedBase);        if (!NT_SUCCESS(Status))        {            DPRINT1("MmUnmapViewInSessionSpace failed: 0x%lx/n", Status);            bResult = FALSE;        }    }    /* Check if we should free the section as well */    if (pSection)    {        /* Dereference the kernel section */        ObDereferenceObject(pSection->pvSectionObject);        /* Finally free the section memory itself */        EngFreeMem(pSection);    }    return bResult;}

VOIDNTAPIGdiPoolDestroy(PGDI_POOL pPool){    PGDI_POOL_SECTION pSection;    PLIST_ENTRY ple;    /* Loop all empty sections, removing them */    while (!IsListEmpty(&pPool->leEmptyList))    {        /* Delete the section */        ple = RemoveHeadList(&pPool->leEmptyList);        pSection = CONTAINING_RECORD(ple, GDI_POOL_SECTION, leInUseLink);        GdiPoolDeleteSection(pPool, pSection);    }    /* Loop all ready sections, removing them */    while (!IsListEmpty(&pPool->leInUseList))    {        /* Delete the section */        ple = RemoveHeadList(&pPool->leInUseList);        pSection = CONTAINING_RECORD(ple, GDI_POOL_SECTION, leInUseLink);        GdiPoolDeleteSection(pPool, pSection);    }    DBG_CLEANUP_EVENT_LIST(&pPool->slhLog);    EngFreeMem(pPool);}

VOIDDrvDisableDriver(    VOID    ){   EngFreeMem(gpgset);}

staticVOIDGdiPoolDeleteSection(PGDI_POOL pPool, PGDI_POOL_SECTION pSection){    NTSTATUS status;    SIZE_T cjSize = 0;    /* Should not have any allocations */    if (pSection->cAllocCount != 0)    {        DPRINT1("There are %lu allocations left, section=%p, pool=%p/n",                pSection->cAllocCount, pSection, pPool);        DBG_DUMP_EVENT_LIST(&pPool->slhLog);        ASSERT(FALSE);    }    /* Release the virtual memory */    status = ZwFreeVirtualMemory(NtCurrentProcess(),                                 &pSection->pvBaseAddress,                                 &cjSize,                                 MEM_RELEASE);    ASSERT(NT_SUCCESS(status));    /* Free the section object */    EngFreeMem(pSection);}

VOID DrvDeleteDeviceBitmap(DHSURF  dhsurf){    DSURF*   pdsurf;    PDEV*    ppdev;    SURFOBJ* psoDib;    HSURF    hsurfDib;    pdsurf = (DSURF*) dhsurf;    ppdev  = pdsurf->ppdev;    if (pdsurf->dt == DT_SCREEN)    {        pohFree(ppdev, pdsurf->poh);    }    else    {        ASSERTDD(pdsurf->dt == DT_DIB, "Expected DIB type");        psoDib = pdsurf->pso;        // Get the hsurf from the SURFOBJ before we unlock it (it's not        // legal to dereference psoDib when it's unlocked):        hsurfDib = psoDib->hsurf;        EngUnlockSurface(psoDib);        EngDeleteSurface(hsurfDib);    }    EngFreeMem(pdsurf);}

/* * @implemented */VOIDAPIENTRYEngDeleteClip(    _In_ _Post_ptr_invalid_ CLIPOBJ *pco){    EngFreeMem(ObjToGDI(pco, CLIP));}

VOIDNTAPIEBRUSHOBJ_vCleanup(EBRUSHOBJ *pebo){    /* Check if there's a GDI realisation */    if (pebo->pengbrush)    {        /* Unlock the bitmap again */        SURFACE_ShareUnlockSurface(pebo->pengbrush);        pebo->pengbrush = NULL;    }    /* Check if there's a driver's realisation */    if (pebo->BrushObject.pvRbrush)    {        /* Free allocated driver memory */        EngFreeMem(pebo->BrushObject.pvRbrush);        pebo->BrushObject.pvRbrush = NULL;    }    if (pebo->psoMask != NULL)    {        SURFACE_ShareUnlockSurface(pebo->psoMask);        pebo->psoMask = NULL;    }    /* Dereference the palettes */    PALETTE_ShareUnlockPalette(pebo->ppalSurf);    PALETTE_ShareUnlockPalette(pebo->ppalDC);    if (pebo->ppalDIB) PALETTE_ShareUnlockPalette(pebo->ppalDIB);}

VOIDFASTCALLIntEngUpdateClipRegion(    XCLIPOBJ* Clip,    ULONG count,    const RECTL* pRect,    const RECTL* rcBounds){    if(count > 1)    {        RECTL* NewRects = EngAllocMem(0, FIELD_OFFSET(ENUMRECTS, arcl[count]), GDITAG_CLIPOBJ);        if(NewRects != NULL)        {            Clip->RectCount = count;            Clip->EnumOrder = CD_ANY;            RtlCopyMemory(NewRects, pRect, count * sizeof(RECTL));            Clip->ClipObj.iDComplexity = DC_COMPLEX;            Clip->ClipObj.iFComplexity = ((Clip->RectCount <= 4) ? FC_RECT4 : FC_COMPLEX);            Clip->ClipObj.iMode = TC_RECTANGLES;            Clip->ClipObj.rclBounds = *rcBounds;            if (Clip->Rects != &Clip->ClipObj.rclBounds)                EngFreeMem(Clip->Rects);            Clip->Rects = NewRects;        }    }    else    {        Clip->EnumOrder = CD_ANY;        Clip->ClipObj.iDComplexity = (((rcBounds->top == rcBounds->bottom) &&                                     (rcBounds->left == rcBounds->right))                                     ? DC_TRIVIAL : DC_RECT);        Clip->ClipObj.iFComplexity = FC_RECT;        Clip->ClipObj.iMode = TC_RECTANGLES;        Clip->ClipObj.rclBounds = *rcBounds;        Clip->RectCount = 1;        if (Clip->Rects != &Clip->ClipObj.rclBounds)            EngFreeMem(Clip->Rects);        Clip->Rects = &Clip->ClipObj.rclBounds;    }}

VOIDAPIENTRYBmfdDestroyFont(    IN FONTOBJ *pfo){    /* Free the font realization info */    EngFreeMem(pfo->pvProducer);    pfo->pvProducer = NULL;}

FASTCALLPOLYGONFILL_MakeEdgeList(PPOINT Points, int Count){  int CurPt = 0;  FILL_EDGE_LIST* list = 0;  FILL_EDGE* e = 0;  if ( 0 == Points || 2 > Count )    return 0;  list = (FILL_EDGE_LIST*)EngAllocMem(FL_ZERO_MEMORY, sizeof(FILL_EDGE_LIST), FILL_EDGE_ALLOC_TAG);  if ( 0 == list )    goto fail;  list->Count = 0;  list->Edges = (FILL_EDGE**)EngAllocMem(FL_ZERO_MEMORY, Count*sizeof(FILL_EDGE*), FILL_EDGE_ALLOC_TAG);  if ( !list->Edges )    goto fail;  memset ( list->Edges, 0, Count * sizeof(FILL_EDGE*) );  for ( CurPt = 1; CurPt < Count; ++CurPt )  {    e = POLYGONFILL_MakeEdge ( Points[CurPt-1], Points[CurPt] );    if ( !e )      goto fail;    // if a straight horizontal line - who cares?    if ( !e->absdy )      EngFreeMem ( e );    else      list->Edges[list->Count++] = e;  }  e = POLYGONFILL_MakeEdge ( Points[CurPt-1], Points[0] );  if ( !e )    goto fail;  if ( !e->absdy )    EngFreeMem ( e );  else    list->Edges[list->Count++] = e;  return list;fail:  DPRINT1("Out Of MEMORY!!/n");  POLYGONFILL_DestroyEdgeList ( list );  return 0;}

BOOLTestFdUnloadFontFileTE (    HFF hff    ){    if (hff)        EngFreeMem((PVOID)hff);    return TRUE;}

/* Called to free resources allocated for device in VBoxDispDrvEnablePDEV */VOID APIENTRY VBoxDispDrvDisablePDEV(DHPDEV dhpdev){    LOGF_ENTER();    VBoxDispDestroyPalette((PVBOXDISPDEV) dhpdev);    EngFreeMem(dhpdev);    LOGF_LEAVE();}

/* * @implemented */VOIDAPIENTRYEngDeleteClip(    _In_ _Post_ptr_invalid_ CLIPOBJ *pco){    XCLIPOBJ* Clip = CONTAINING_RECORD(pco, XCLIPOBJ, ClipObj);    TRACE("Deleting %p./n");    IntEngFreeClipResources(Clip);    EngFreeMem(Clip);}

VOID vUninitializePalette(PDEV* ppdev){    // Delete the default palette if we created one:    if (ppdev->hpalDefault != 0)        EngDeletePalette(ppdev->hpalDefault);    if (ppdev->pPal != (PALETTEENTRY*) NULL)        EngFreeMem(ppdev->pPal);}

/* Returns video modes supported by our device/driver * Note: If we fail here we'd be asked to enter [email
C++ EngSetLastError函数代码示例
C++ EngDeviceIoControl函数代码示例