Adding upstream version 1.2.2.upstream/1.2.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2704 insertions, 0 deletions

diff --git a/src/3rdparty/libuemf/uemf_print.c b/src/3rdparty/libuemf/uemf_print.c
new file mode 100644
index 0000000..74fa5ae
--- /dev/null
+++ b/src/3rdparty/libuemf/uemf_print.c
@@ -0,0 +1,2704 @@
+/**
+  @file uemf_print.c
+  
+  @brief Functions for printing EMF records
+*/
+
+/*
+File:      uemf_print.c
+Version:   0.0.22
+Date:      12-MAY-2020
+Author:    David Mathog, Biology Division, Caltech
+email:     mathog@caltech.edu
+Copyright: 2020 David Mathog and California Institute of Technology (Caltech)
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stddef.h> /* for offsetof() macro */
+#include <string.h>
+#include "uemf.h"
+#include "upmf_print.h"
+#include "uemf_safe.h"
+
+//! \cond
+#define UNUSED(x) (void)(x)
+/* This bit of code is used all over the place, so reduce it to a DEFINITION */
+#define IF_MEM_UNSAFE_PRINT_AND_RETURN(A,B,C) if(IS_MEM_UNSAFE(A,B,C)){printf("   record corruption HERE\n"); return; }
+
+/* one needed prototype */
+void U_swap4(void *ul, unsigned int count);
+//! \endcond
+
+/** 
+    \brief calculate a CRC32 value for record
+    \returns CRC32 value calculated for record
+    \param record pointer to the first byte
+    \param Size   number of bytes in the record
+
+Code based on example crc32b  here:
+   http://www.hackersdelight.org/hdcodetxt/crc.c.txt
+*/
+uint32_t lu_crc32(const char *record, uint32_t Size){
+   const unsigned char *message = (const unsigned char *)record;
+   uint32_t i, j;
+   uint32_t crc, mask;
+
+   crc = 0xFFFFFFFF;
+   for(i=0;i<Size;i++){     // over all bytes
+      crc = crc ^ *message++;
+      for (j = 0; j < 8; j++) { // over all bits
+         mask = -(crc & 1);
+         crc = (crc >> 1) ^ (0xEDB88320 & mask);
+      }
+   }
+   return ~crc;
+}
+
+/** 
+    \brief Print some number of hex bytes
+    \param buf pointer to the first byte
+    \param num number of bytes
+*/
+void hexbytes_print(uint8_t *buf,unsigned int num){
+   for(; num; num--,buf++){
+      printf("%2.2X",*buf);
+   }
+}
+
+
+/* **********************************************************************************************
+   These functions print standard objects used in the EMR records.
+   The low level ones do not append EOL.
+*********************************************************************************************** */
+
+
+
+/** 
+    \brief Print a U_COLORREF object.
+    \param color  U_COLORREF object    
+*/
+void colorref_print(
+      U_COLORREF color
+   ){
+   printf("{%u,%u,%u} ",color.Red,color.Green,color.Blue);
+}
+
+
+/**
+    \brief Print a U_RGBQUAD object.
+    \param color  U_RGBQUAD object    
+*/
+void rgbquad_print(
+      U_RGBQUAD color
+   ){
+   printf("{%u,%u,%u,%u} ",color.Blue,color.Green,color.Red,color.Reserved);
+}
+
+/**
+    \brief Print rect and rectl objects from Upper Left and Lower Right corner points.
+    \param rect U_RECTL object
+*/
+void rectl_print(
+      U_RECTL rect
+    ){
+    printf("{%d,%d,%d,%d} ",rect.left,rect.top,rect.right,rect.bottom);
+}
+
+/**
+    \brief Print a U_SIZEL object.
+    \param sz U_SizeL object
+*/
+void sizel_print(
+       U_SIZEL sz
+    ){
+    printf("{%d,%d} ",sz.cx ,sz.cy);
+} 
+
+/**
+    \brief Print a U_POINTL object
+    \param pt U_POINTL object
+*/
+void pointl_print(
+       U_POINTL pt
+    ){
+    printf("{%d,%d} ",pt.x ,pt.y);
+} 
+
+/**
+    \brief Print a pointer to a U_POINT16 object
+    \param pt pointer to a U_POINT16 object
+    Warning - WMF data may contain unaligned U_POINT16, do not call
+    this routine with a pointer to such data!
+*/
+void point16_print(
+       U_POINT16 pt
+    ){
+    printf("{%d,%d} ",pt.x ,pt.y);
+} 
+
+/**
+    \brief Print a U_LCS_GAMMA object
+    \param lg U_LCS_GAMMA object
+*/
+void lcs_gamma_print(
+      U_LCS_GAMMA lg
+   ){
+   uint8_t tmp;
+   tmp = lg.ignoreHi; printf("ignoreHi:%u ",tmp);
+   tmp = lg.intPart ; printf("intPart :%u ",tmp);
+   tmp = lg.fracPart; printf("fracPart:%u ",tmp);
+   tmp = lg.ignoreLo; printf("ignoreLo:%u ",tmp);
+}
+
+/**
+    \brief Print a U_LCS_GAMMARGB object
+    \param lgr U_LCS_GAMMARGB object
+*/
+void lcs_gammargb_print(
+      U_LCS_GAMMARGB lgr
+   ){
+   printf("lcsGammaRed:");   lcs_gamma_print(lgr.lcsGammaRed  );
+   printf("lcsGammaGreen:"); lcs_gamma_print(lgr.lcsGammaGreen);
+   printf("lcsGammaBlue:");  lcs_gamma_print(lgr.lcsGammaBlue );
+}
+
+/**
+    \brief Print a U_TRIVERTEX object.
+    \param tv U_TRIVERTEX object.
+*/
+void trivertex_print(
+      U_TRIVERTEX tv
+   ){
+   printf("{{%d,%d},{%u,%u,%u,%u}} ",tv.x,tv.y,tv.Red,tv.Green,tv.Blue,tv.Alpha);
+}
+
+/**
+    \brief Print a U_GRADIENT3 object.
+    \param g3 U_GRADIENT3 object.
+*/
+void gradient3_print(
+      U_GRADIENT3 g3
+   ){
+   printf("{%u,%u,%u} ",g3.Vertex1,g3.Vertex2,g3.Vertex3);
+}
+
+/**
+    \brief Print a U_GRADIENT4 object.
+    \param g4 U_GRADIENT4 object.
+*/
+void gradient4_print(
+      U_GRADIENT4 g4
+   ){
+   printf("{%u,%u} ",g4.UpperLeft,g4.LowerRight);
+}
+
+/**
+    \brief Print a U_LOGBRUSH object.
+    \param lb U_LOGBRUSH object.
+*/
+void logbrush_print(
+      U_LOGBRUSH lb  
+   ){
+    printf("lbStyle:0x%8.8X ",  lb.lbStyle);
+    printf("lbColor:");         colorref_print(lb.lbColor);
+    printf("lbHatch:0x%8.8X ",  lb.lbHatch);
+}
+
+/**
+    \brief Print a U_XFORM object.
+    \param xform U_XFORM object
+*/
+void xform_print(
+      U_XFORM xform
+   ){
+   printf("{%f,%f.%f,%f,%f,%f} ",xform.eM11,xform.eM12,xform.eM21,xform.eM22,xform.eDx,xform.eDy);
+}
+
+/**
+  \brief Print a U_CIEXYZ object
+  \param ciexyz U_CIEXYZ object
+*/
+void ciexyz_print(
+      U_CIEXYZ ciexyz
+   ){
+   printf("{%d,%d.%d} ",ciexyz.ciexyzX,ciexyz.ciexyzY,ciexyz.ciexyzZ);
+    
+}
+
+/**
+  \brief Print a U_CIEXYZTRIPLE object
+  \param cie3 U_CIEXYZTRIPLE object
+*/
+void ciexyztriple_print(
+      U_CIEXYZTRIPLE cie3
+   ){
+   printf("{Red:");     ciexyz_print(cie3.ciexyzRed  );
+   printf(", Green:");  ciexyz_print(cie3.ciexyzGreen);
+   printf(", Blue:");   ciexyz_print(cie3.ciexyzBlue );
+   printf("} ");
+}
+/**
+    \brief Print a U_LOGCOLORSPACEA object.
+    \param lcsa     U_LOGCOLORSPACEA object
+*/
+void logcolorspacea_print(
+      U_LOGCOLORSPACEA lcsa
+   ){
+   printf("lcsSignature:%u ",lcsa.lcsSignature);
+   printf("lcsVersion:%u ",  lcsa.lcsVersion  );
+   printf("lcsSize:%u ",     lcsa.lcsSize     );
+   printf("lcsCSType:%d ",    lcsa.lcsCSType   );
+   printf("lcsIntent:%d ",    lcsa.lcsIntent   );
+   printf("lcsEndpoints:");   ciexyztriple_print(lcsa.lcsEndpoints);
+   printf("lcsGammaRGB: ");   lcs_gammargb_print(lcsa.lcsGammaRGB );
+   printf("filename:%s ",     lcsa.lcsFilename );
+}
+
+/**
+
+    \brief Print a U_LOGCOLORSPACEW object.
+    \param lcsa U_LOGCOLORSPACEW object                                               
+*/
+void logcolorspacew_print(
+      U_LOGCOLORSPACEW lcsa
+   ){
+   char *string;
+   printf("lcsSignature:%d ",lcsa.lcsSignature);
+   printf("lcsVersion:%d ",  lcsa.lcsVersion  );
+   printf("lcsSize:%d ",     lcsa.lcsSize     );
+   printf("lcsCSType:%d ",   lcsa.lcsCSType   );
+   printf("lcsIntent:%d ",   lcsa.lcsIntent   );
+   printf("lcsEndpoints:");   ciexyztriple_print(lcsa.lcsEndpoints);
+   printf("lcsGammaRGB: ");   lcs_gammargb_print(lcsa.lcsGammaRGB );
+   string = U_Utf16leToUtf8(lcsa.lcsFilename, U_MAX_PATH, NULL);
+   printf("filename:%s ",   string );
+   free(string);
+}
+
+/**
+    \brief Print a U_PANOSE object.
+    \param panose U_PANOSE object
+*/
+void panose_print(
+      U_PANOSE panose
+    ){
+    printf("bFamilyType:%u ",     panose.bFamilyType     );
+    printf("bSerifStyle:%u ",     panose.bSerifStyle     );
+    printf("bWeight:%u ",         panose.bWeight         );
+    printf("bProportion:%u ",     panose.bProportion     );
+    printf("bContrast:%u ",       panose.bContrast       );
+    printf("bStrokeVariation:%u ",panose.bStrokeVariation);
+    printf("bArmStyle:%u ",       panose.bArmStyle       );
+    printf("bLetterform:%u ",     panose.bLetterform     );
+    printf("bMidline:%u ",        panose.bMidline        );
+    printf("bXHeight:%u ",        panose.bXHeight        );
+}
+
+/**
+    \brief Print a U_LOGFONT object.
+    \param lf   U_LOGFONT object
+*/
+void logfont_print(
+       U_LOGFONT lf
+   ){
+   char *string;
+   printf("lfHeight:%d ",            lf.lfHeight        );
+   printf("lfWidth:%d ",             lf.lfWidth         );
+   printf("lfEscapement:%d ",        lf.lfEscapement    );
+   printf("lfOrientation:%d ",       lf.lfOrientation   );
+   printf("lfWeight:%d ",            lf.lfWeight        );
+   printf("lfItalic:0x%2.2X ",         lf.lfItalic        );
+   printf("lfUnderline:0x%2.2X ",      lf.lfUnderline     );
+   printf("lfStrikeOut:0x%2.2X ",      lf.lfStrikeOut     );
+   printf("lfCharSet:0x%2.2X ",        lf.lfCharSet       );
+   printf("lfOutPrecision:0x%2.2X ",   lf.lfOutPrecision  );
+   printf("lfClipPrecision:0x%2.2X ",  lf.lfClipPrecision );
+   printf("lfQuality:0x%2.2X ",        lf.lfQuality       );
+   printf("lfPitchAndFamily:0x%2.2X ", lf.lfPitchAndFamily);
+     string = U_Utf16leToUtf8(lf.lfFaceName, U_LF_FACESIZE, NULL);
+   printf("lfFaceName:%s ",   string );
+   free(string);
+}
+
+/**
+    \brief Print a U_LOGFONT_PANOSE object.
+    \return U_LOGFONT_PANOSE object
+*/
+void logfont_panose_print(
+      U_LOGFONT_PANOSE lfp
+   ){    
+   char *string;
+   printf("elfLogFont:");       logfont_print(lfp.elfLogFont);
+     string = U_Utf16leToUtf8(lfp.elfFullName, U_LF_FULLFACESIZE, NULL);
+   printf("elfFullName:%s ",    string );
+   free(string);
+     string = U_Utf16leToUtf8(lfp.elfStyle, U_LF_FACESIZE, NULL);
+   printf("elfStyle:%s ",       string );
+   free(string);
+   printf("elfVersion:%u "      ,lfp.elfVersion  );
+   printf("elfStyleSize:%u "    ,lfp.elfStyleSize);
+   printf("elfMatch:%u "        ,lfp.elfMatch    );
+   printf("elfReserved:%u "     ,lfp.elfReserved );
+   printf("elfVendorId:");      hexbytes_print((uint8_t *)lfp.elfVendorId,U_ELF_VENDOR_SIZE); printf(" ");
+   printf("elfCulture:%u "      ,lfp.elfCulture  );
+   printf("elfPanose:");        panose_print(lfp.elfPanose);
+}
+
+/**
+    \brief Print a pointer to U_BITMAPINFOHEADER object.
+
+    This may be called indirectly from WMF _print routines, where problems could occur
+    if the data was passed as the struct or a pointer to the struct, as the struct may not
+    be aligned in memory.
+
+    \returns Actual number of color table entries.
+    \param Bmih pointer to a U_BITMAPINFOHEADER object
+*/
+int bitmapinfoheader_print(
+      const char *Bmih
+   ){
+   uint32_t  utmp4;
+   int32_t   tmp4;
+   int16_t   tmp2;
+   int       Colors, BitCount, Width, Height, RealColors;
+
+   /* DIB from a WMF may not be properly aligned on a 4 byte boundary, will be aligned on a 2 byte boundary */
+
+   memcpy(&utmp4, Bmih + offsetof(U_BITMAPINFOHEADER,biSize),          4);  printf("biSize:%u "            ,utmp4 );
+   memcpy(&tmp4,  Bmih + offsetof(U_BITMAPINFOHEADER,biWidth),         4);  printf("biWidth:%d "           ,tmp4  );
+   Width = tmp4;
+   memcpy(&tmp4,  Bmih + offsetof(U_BITMAPINFOHEADER,biHeight),        4);  printf("biHeight:%d "          ,tmp4  );
+   Height = tmp4;
+   memcpy(&tmp2,  Bmih + offsetof(U_BITMAPINFOHEADER,biPlanes),        2);  printf("biPlanes:%u "          ,tmp2  );
+   memcpy(&tmp2,  Bmih + offsetof(U_BITMAPINFOHEADER,biBitCount),      2);  printf("biBitCount:%u "        ,tmp2  );
+   BitCount = tmp2;
+   memcpy(&utmp4, Bmih + offsetof(U_BITMAPINFOHEADER,biCompression),   4);  printf("biCompression:%u "     ,utmp4 );
+   memcpy(&utmp4, Bmih + offsetof(U_BITMAPINFOHEADER,biSizeImage),     4);  printf("biSizeImage:%u "       ,utmp4 );
+   memcpy(&tmp4,  Bmih + offsetof(U_BITMAPINFOHEADER,biXPelsPerMeter), 4);  printf("biXPelsPerMeter:%d "   ,tmp4  );
+   memcpy(&tmp4,  Bmih + offsetof(U_BITMAPINFOHEADER,biYPelsPerMeter), 4);  printf("biYPelsPerMeter:%d "   ,tmp4  );
+   memcpy(&utmp4, Bmih + offsetof(U_BITMAPINFOHEADER,biClrUsed),       4);  printf("biClrUsed:%u "         ,utmp4 );
+   Colors = utmp4;
+   memcpy(&utmp4, Bmih + offsetof(U_BITMAPINFOHEADER,biClrImportant),  4);  printf("biClrImportant:%u "    ,utmp4 );
+   RealColors = get_real_color_icount(Colors, BitCount, Width, Height);
+   printf("ColorEntries:%d ",RealColors);
+   return(RealColors);
+}
+
+
+/**
+    \brief Print a Pointer to a U_BITMAPINFO object.
+    \param Bmi Pointer to a U_BITMAPINFO object
+    \param blimit   Pointer to the first byte after after this record
+    This may be called from WMF _print routines, where problems could occur
+    if the data was passed as the struct or a pointer to the struct, as the struct may not
+    be aligned in memory.
+*/
+void bitmapinfo_print(
+      const char *Bmi,
+      const char *blimit
+   ){
+   int       i,k;
+   int       ClrUsed;
+   U_RGBQUAD BmiColor;
+   printf("BmiHeader: ");
+   IF_MEM_UNSAFE_PRINT_AND_RETURN(Bmi, offsetof(U_BITMAPINFO,bmiHeader) + sizeof(U_BITMAPINFOHEADER), blimit);
+   ClrUsed = bitmapinfoheader_print(Bmi + offsetof(U_BITMAPINFO,bmiHeader));
+   if(ClrUsed){
+      k= offsetof(U_BITMAPINFO,bmiColors);
+      IF_MEM_UNSAFE_PRINT_AND_RETURN(Bmi, offsetof(U_BITMAPINFO,bmiColors) + ClrUsed*sizeof(U_RGBQUAD), blimit);
+      for(i=0; i<ClrUsed; i++, k+= sizeof(U_RGBQUAD)){
+         memcpy(&BmiColor, Bmi+k, sizeof(U_RGBQUAD));
+         printf("%d:",i); rgbquad_print(BmiColor);
+      }
+   }
+}
+
+/**
+    \brief Print a U_BLEND object.
+    \param blend a U_BLEND object
+*/
+void blend_print(
+      U_BLEND blend
+   ){
+   printf("Operation:%u " ,blend.Operation);
+   printf("Flags:%u "     ,blend.Flags    );
+   printf("Global:%u "    ,blend.Global   );
+   printf("Op:%u "        ,blend.Op       );
+}
+
+/**
+    \brief Print a pointer to a U_EXTLOGPEN object.
+    \param elp   PU_EXTLOGPEN object
+*/
+void extlogpen_print(
+      PU_EXTLOGPEN elp
+   ){
+   unsigned int i;
+   U_STYLEENTRY *elpStyleEntry;
+   printf("elpPenStyle:0x%8.8X "   ,elp->elpPenStyle  );
+   printf("elpWidth:%u "           ,elp->elpWidth     );
+   printf("elpBrushStyle:0x%8.8X " ,elp->elpBrushStyle);
+   printf("elpColor");              colorref_print(elp->elpColor);
+   printf("elpHatch:%d "           ,elp->elpHatch     );
+   printf("elpNumEntries:%u "      ,elp->elpNumEntries);
+   if(elp->elpNumEntries){
+     printf("elpStyleEntry:");
+     elpStyleEntry = (uint32_t *) elp->elpStyleEntry;
+     for(i=0;i<elp->elpNumEntries;i++){
+        printf("%d:%u ",i,elpStyleEntry[i]);
+     }
+   }
+}
+
+/**
+    \brief Print a U_LOGPEN object.
+    \param lp  U_LOGPEN object
+    
+*/
+void logpen_print(
+      U_LOGPEN lp
+   ){
+   printf("lopnStyle:0x%8.8X "    ,lp.lopnStyle  );
+   printf("lopnWidth:");      pointl_print(  lp.lopnWidth  );
+   printf("lopnColor:");      colorref_print(lp.lopnColor );
+} 
+
+/**
+    \brief Print a U_LOGPLTNTRY object.
+    \param lpny Ignore U_LOGPLTNTRY object.
+*/
+void logpltntry_print(
+      U_LOGPLTNTRY lpny
+   ){
+   printf("peReserved:%u " ,lpny.peReserved );
+   printf("peRed:%u "      ,lpny.peRed      );
+   printf("peGreen:%u "    ,lpny.peGreen    );
+   printf("peBlue:%u "     ,lpny.peBlue     );
+}
+
+/**
+    \brief Print a pointer to a U_LOGPALETTE object.
+    \param lp  Pointer to a U_LOGPALETTE object.
+*/
+void logpalette_print(
+      PU_LOGPALETTE lp
+   ){
+   int            i;
+   PU_LOGPLTNTRY palPalEntry;
+   printf("palVersion:%u ",    lp->palVersion );
+   printf("palNumEntries:%u ", lp->palNumEntries );
+   if(lp->palNumEntries){
+     palPalEntry = (PU_LOGPLTNTRY) &(lp->palPalEntry);
+     for(i=0;i<lp->palNumEntries;i++){
+        printf("%d:",i); logpltntry_print(palPalEntry[i]);
+     }
+   }
+}
+
+/**
+    \brief Print a U_RGNDATAHEADER object.
+    \param rdh  U_RGNDATAHEADER object
+*/
+void rgndataheader_print(
+      U_RGNDATAHEADER rdh
+   ){
+   printf("dwSize:%u ",   rdh.dwSize   );
+   printf("iType:%u ",    rdh.iType    );
+   printf("nCount:%u ",   rdh.nCount   );
+   printf("nRgnSize:%u ", rdh.nRgnSize );
+   printf("rclBounds:");  rectl_print(rdh.rclBounds  );
+}
+
+/**
+    \brief Print a pointer to a U_RGNDATA object.
+    \param rd  pointer to a U_RGNDATA object.
+    \param limit  pointer that sets upper limit for data examination
+*/
+void rgndata_print(
+      PU_RGNDATA rd,
+      const char *blimit
+   ){
+   unsigned int i;
+   PU_RECTL rects;
+   IF_MEM_UNSAFE_PRINT_AND_RETURN(rd, sizeof(U_RGNDATAHEADER), blimit);
+   printf("rdh: ");     rgndataheader_print(rd->rdh ); printf(" rects: ");
+   if(rd->rdh.nCount){
+     rects = (PU_RECTL) &(rd->Buffer);
+     IF_MEM_UNSAFE_PRINT_AND_RETURN(rects, rd->rdh.nCount * sizeof(U_RECTL), blimit);
+     for(i=0;i<rd->rdh.nCount;i++){
+        printf("%d:",i); rectl_print(rects[i]);
+     }
+   }
+}
+
+/**
+    \brief Print a U_COLORADJUSTMENT object.
+    \param ca U_COLORADJUSTMENT object.        
+*/
+void coloradjustment_print(
+      U_COLORADJUSTMENT ca
+   ){
+   printf("caSize:%u "            ,ca.caSize           );
+   printf("caFlags:0x%4.4X "        ,ca.caFlags          );
+   printf("caIlluminantIndex:%u " ,ca.caIlluminantIndex);
+   printf("caRedGamma:%u "        ,ca.caRedGamma       );
+   printf("caGreenGamma:%u "      ,ca.caGreenGamma     );
+   printf("caBlueGamma:%u "       ,ca.caBlueGamma      );
+   printf("caReferenceBlack:%u "  ,ca.caReferenceBlack );
+   printf("caReferenceWhite:%u "  ,ca.caReferenceWhite );
+   printf("caContrast:%d "         ,ca.caContrast       );
+   printf("caBrightness:%d "       ,ca.caBrightness     );
+   printf("caColorfulness:%d "     ,ca.caColorfulness   );
+   printf("caRedGreenTint:%d "     ,ca.caRedGreenTint   );
+}
+
+/**
+    \brief Print a U_PIXELFORMATDESCRIPTOR object.
+    \param pfd  U_PIXELFORMATDESCRIPTOR object
+*/
+void pixelformatdescriptor_print(
+      U_PIXELFORMATDESCRIPTOR pfd
+   ){
+   printf("nSize:%u "           ,pfd.nSize           );
+   printf("nVersion:%u "        ,pfd.nVersion        );
+   printf("dwFlags:0x%8.8X "      ,pfd.dwFlags         );
+   printf("iPixelType:%u "      ,pfd.iPixelType      );
+   printf("cColorBits:%u "      ,pfd.cColorBits      );
+   printf("cRedBits:%u "        ,pfd.cRedBits        );
+   printf("cRedShift:%u "       ,pfd.cRedShift       );
+   printf("cGreenBits:%u "      ,pfd.cGreenBits      );
+   printf("cGreenShift:%u "     ,pfd.cGreenShift     );
+   printf("cBlueBits:%u "       ,pfd.cBlueBits       );
+   printf("cBlueShift:%u "      ,pfd.cBlueShift      );
+   printf("cAlphaBits:%u "      ,pfd.cAlphaBits      );
+   printf("cAlphaShift:%u "     ,pfd.cAlphaShift     );
+   printf("cAccumBits:%u "      ,pfd.cAccumBits      );
+   printf("cAccumRedBits:%u "   ,pfd.cAccumRedBits   );
+   printf("cAccumGreenBits:%u " ,pfd.cAccumGreenBits );
+   printf("cAccumBlueBits:%u "  ,pfd.cAccumBlueBits  );
+   printf("cAccumAlphaBits:%u " ,pfd.cAccumAlphaBits );
+   printf("cDepthBits:%u "      ,pfd.cDepthBits      );
+   printf("cStencilBits:%u "    ,pfd.cStencilBits    );
+   printf("cAuxBuffers:%u "     ,pfd.cAuxBuffers     );
+   printf("iLayerType:%u "      ,pfd.iLayerType      );
+   printf("bReserved:%u "       ,pfd.bReserved       );
+   printf("dwLayerMask:%u "     ,pfd.dwLayerMask     );
+   printf("dwVisibleMask:%u "   ,pfd.dwVisibleMask   );
+   printf("dwDamageMask:%u "    ,pfd.dwDamageMask    );
+}
+
+/**
+    \brief Print a Pointer to a U_EMRTEXT record
+    \param emt      Pointer to a U_EMRTEXT record 
+    \param record   Pointer to the start of the record which contains this U_ERMTEXT
+    \param blimit   Pointer to the first byte after after this record
+    \param type     0 for 8 bit character, anything else for 16 
+*/
+void emrtext_print(
+      const char *emt,
+      const char *record,
+      const char *blimit,
+      int         type
+   ){
+   unsigned int i,off;
+   char *string;
+   PU_EMRTEXT pemt = (PU_EMRTEXT) emt;
+   // constant part
+   printf("ptlReference:");   pointl_print(pemt->ptlReference);
+   printf("nChars:%u "       ,pemt->nChars      );
+   printf("offString:%u "    ,pemt->offString   );
+   if(pemt->offString){
+      if(!type){
+         IF_MEM_UNSAFE_PRINT_AND_RETURN(record, pemt->offString + pemt->nChars*sizeof(char), blimit);
+         printf("string8:<%s> ",record + pemt->offString);
+      }
+      else {
+         IF_MEM_UNSAFE_PRINT_AND_RETURN(record, pemt->offString + pemt->nChars*2*sizeof(char), blimit);
+         string = U_Utf16leToUtf8((uint16_t *)(record + pemt->offString), pemt->nChars, NULL);
+         printf("string16:<%s> ",string);
+         free(string);
+      }
+   }
+   printf("fOptions:0x%8.8X "     ,pemt->fOptions    );
+   off = sizeof(U_EMRTEXT);
+   if(!(pemt->fOptions & U_ETO_NO_RECT)){
+      printf("rcl");   rectl_print( *((U_RECTL *)(emt+off)) );
+      off += sizeof(U_RECTL);
+   }
+   printf("offDx:%u "        , *((U_OFFDX *)(emt+off))   ); off = *(U_OFFDX *)(emt+off);
+   printf("Dx:");
+   for(i=0; i<pemt->nChars; i++, off+=sizeof(uint32_t)){
+      printf("%d:", *((uint32_t *)(record+off))  );
+   }
+}
+
+
+
+
+// hide these from Doxygen
+//! @cond
+/* **********************************************************************************************
+These functions contain shared code used by various U_EMR*_print functions.  These should NEVER be called
+by end user code and to further that end prototypes are NOT provided and they are hidden from Doxygen.
+
+
+   These are (mostly) ordered by U_EMR_* index number.
+      
+   The exceptions:
+   void core3_print(const char *name, const char *label, const char *contents)
+   void core7_print(const char *name, const char *field1, const char *field2, const char *contents)
+   void core8_print(const char *name, const char *contents, int type)
+   
+   
+*********************************************************************************************** */
+
+
+// Functions with the same form starting with U_EMRPOLYBEZIER_print
+void core1_print(const char *name, const char *contents){
+   unsigned int i;
+   UNUSED(name);
+   PU_EMRPOLYLINETO pEmr = (PU_EMRPOLYLINETO) (contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRPOLYBEZIER)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");    rectl_print(pEmr->rclBounds);    printf("\n");
+   printf("   cptl:           %d\n",pEmr->cptl        );
+   printf("   Points:         ");
+   IF_MEM_UNSAFE_PRINT_AND_RETURN(pEmr->aptl, pEmr->cptl*sizeof(U_POINTL), blimit);
+   for(i=0;i<pEmr->cptl; i++){
+      printf("[%d]:",i); pointl_print(pEmr->aptl[i]);
+   }
+   printf("\n");
+}
+
+// Functions with the same form starting with U_EMRPOLYPOLYLINE_print
+void core2_print(const char *name, const char *contents){
+   unsigned int i;
+   UNUSED(name);
+   PU_EMRPOLYPOLYGON pEmr = (PU_EMRPOLYPOLYGON) (contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRPOLYPOLYGON)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");    rectl_print(pEmr->rclBounds);    printf("\n");
+   printf("   nPolys:         %d\n",pEmr->nPolys        );
+   printf("   cptl:           %d\n",pEmr->cptl          );
+   printf("   Counts:         ");
+   IF_MEM_UNSAFE_PRINT_AND_RETURN(pEmr->aPolyCounts, pEmr->nPolys*sizeof(U_POLYCOUNTS), blimit);
+   for(i=0;i<pEmr->nPolys; i++){
+      printf(" [%d]:%d ",i,pEmr->aPolyCounts[i] );
+   }
+   printf("\n");
+   PU_POINTL paptl = (PU_POINTL)((char *)pEmr->aPolyCounts + sizeof(uint32_t)* pEmr->nPolys);
+   printf("   Points:         ");
+   IF_MEM_UNSAFE_PRINT_AND_RETURN(paptl, pEmr->cptl*sizeof(U_POINTL), blimit);
+   for(i=0;i<pEmr->cptl; i++){
+      printf(" [%d]:",i); pointl_print(paptl[i]);
+   }
+   printf("\n");
+}
+
+
+// Functions with the same form starting with U_EMRSETMAPMODE_print
+void core3_print(const char *name, const char *label, const char *contents){
+   UNUSED(name);
+   /* access violation is impossible for these because there are no counts or offsets */
+   PU_EMRSETMAPMODE pEmr   = (PU_EMRSETMAPMODE)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRSETMAPMODE)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   if(!strcmp(label,"crColor:")){
+      printf("   %-15s ",label); colorref_print(*(U_COLORREF *)&(pEmr->iMode)); printf("\n");
+   }
+   else if(!strcmp(label,"iMode:")){
+      printf("   %-15s 0x%8.8X\n",label,pEmr->iMode     );
+   }
+   else {
+      printf("   %-15s %d\n",label,pEmr->iMode        );
+   }
+} 
+
+// Functions taking a single U_RECT or U_RECTL, starting with U_EMRELLIPSE_print, also U_EMRFILLPATH_print, 
+void core4_print(const char *name, const char *contents){
+   UNUSED(name);
+   PU_EMRELLIPSE pEmr      = (PU_EMRELLIPSE)(   contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRELLIPSE)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   printf("   rclBox:         ");  rectl_print(pEmr->rclBox);  printf("\n");
+} 
+
+// Functions with the same form starting with U_EMRPOLYBEZIER16_print
+void core6_print(const char *name, const char *contents){
+   UNUSED(name);
+   unsigned int i;
+   PU_EMRPOLYBEZIER16 pEmr = (PU_EMRPOLYBEZIER16) (contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRPOLYBEZIER16)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");    rectl_print(pEmr->rclBounds);    printf("\n");
+   printf("   cpts:           %d\n",pEmr->cpts        );
+   printf("   Points:         ");
+   PU_POINT16 papts = (PU_POINT16)(&(pEmr->apts));
+   IF_MEM_UNSAFE_PRINT_AND_RETURN(papts, pEmr->cpts*sizeof(U_POINT16), blimit);
+   for(i=0; i<pEmr->cpts; i++){
+      printf(" [%d]:",i);  point16_print(papts[i]);
+   }
+   printf("\n");
+} 
+
+
+// Records with the same form starting with U_EMRSETWINDOWEXTEX_print
+// CAREFUL, in the _set equivalents all functions with two uint32_t values are mapped here, and member names differ, consequently
+//   print routines must supply the names of the two arguments.  These cannot be null.  If the second one is 
+//   empty the values are printed as a pair {x,y}, otherwise each is printed with its own label on a separate line.
+void core7_print(const char *name, const char *field1, const char *field2, const char *contents){
+   UNUSED(name);
+   PU_EMRGENERICPAIR pEmr = (PU_EMRGENERICPAIR) (contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRGENERICPAIR)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   if(*field2){
+      printf("   %-15s %d\n",field1,pEmr->pair.x);
+      printf("   %-15s %d\n",field2,pEmr->pair.y);
+   }
+   else {
+      printf("   %-15s {%d,%d}\n",field1,pEmr->pair.x,pEmr->pair.y);
+   } 
+}
+
+// For U_EMREXTTEXTOUTA and U_EMREXTTEXTOUTW, type=0 for the first one
+void core8_print(const char *name, const char *contents, int type){
+   UNUSED(name);
+   PU_EMREXTTEXTOUTA pEmr = (PU_EMREXTTEXTOUTA) (contents);
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   iGraphicsMode:  %u\n",pEmr->iGraphicsMode );
+   printf("   rclBounds:      ");    rectl_print(pEmr->rclBounds);                              printf("\n");
+   printf("   exScale:        %f\n",pEmr->exScale        );
+   printf("   eyScale:        %f\n",pEmr->eyScale        );
+   printf("   emrtext:        ");
+      emrtext_print(contents + sizeof(U_EMREXTTEXTOUTA) - sizeof(U_EMRTEXT),contents,blimit,type);
+      printf("\n");
+} 
+
+// Functions that take a rect and a pair of points, starting with U_EMRARC_print
+void core9_print(const char *name, const char *contents){
+   UNUSED(name);
+   PU_EMRARC pEmr = (PU_EMRARC) (contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRARC)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   printf("   rclBox:         ");    rectl_print(pEmr->rclBox);    printf("\n");
+   printf("   ptlStart:       ");  pointl_print(pEmr->ptlStart);   printf("\n");
+   printf("   ptlEnd:         ");    pointl_print(pEmr->ptlEnd);   printf("\n");
+}
+
+// Functions with the same form starting with U_EMRPOLYPOLYLINE16_print
+void core10_print(const char *name, const char *contents){
+   UNUSED(name);
+   unsigned int i;
+   PU_EMRPOLYPOLYLINE16 pEmr = (PU_EMRPOLYPOLYLINE16) (contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRPOLYPOLYLINE16)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");    rectl_print(pEmr->rclBounds);    printf("\n");
+   printf("   nPolys:         %d\n",pEmr->nPolys        );
+   printf("   cpts:           %d\n",pEmr->cpts          );
+   printf("   Counts:         ");
+   IF_MEM_UNSAFE_PRINT_AND_RETURN(&(pEmr->aPolyCounts), pEmr->nPolys*sizeof(U_POLYCOUNTS), blimit);
+   for(i=0;i<pEmr->nPolys; i++){
+      printf(" [%d]:%d ",i,pEmr->aPolyCounts[i] );
+   }
+   printf("\n");
+   printf("   Points:         ");
+   PU_POINT16 papts = (PU_POINT16)((char *)pEmr->aPolyCounts + pEmr->nPolys*sizeof(U_POLYCOUNTS) );
+   IF_MEM_UNSAFE_PRINT_AND_RETURN(papts, pEmr->cpts*sizeof(U_POINT16), blimit);
+   for(i=0; i<pEmr->cpts; i++){
+      printf(" [%d]:",i);  point16_print(papts[i]);
+   }
+   printf("\n");
+
+} 
+
+// Functions with the same form starting with  U_EMRINVERTRGN_print and U_EMRPAINTRGN_print,
+void core11_print(const char *name, const char *contents){
+   UNUSED(name);
+   PU_EMRINVERTRGN pEmr = (PU_EMRINVERTRGN) (contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRINVERTRGN)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");    rectl_print(pEmr->rclBounds);    printf("\n");
+   printf("   cbRgnData:      %d\n",pEmr->cbRgnData);
+   printf("   RegionData:");
+   const char *minptr = MAKE_MIN_PTR(((const char *) &pEmr->RgnData + pEmr->cbRgnData),blimit);
+   rgndata_print(pEmr->RgnData, minptr);
+   printf("\n");
+} 
+
+
+// common code for U_EMRCREATEMONOBRUSH_print and U_EMRCREATEDIBPATTERNBRUSHPT_print,
+void core12_print(const char *name, const char *contents){
+   UNUSED(name);
+   PU_EMRCREATEMONOBRUSH pEmr = (PU_EMRCREATEMONOBRUSH) (contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRCREATEMONOBRUSH)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   ihBrush:      %u\n",pEmr->ihBrush );
+   printf("   iUsage :      %u\n",pEmr->iUsage  );
+   printf("   offBmi :      %u\n",pEmr->offBmi  );
+   printf("   cbBmi  :      %u\n",pEmr->cbBmi   );
+   if(pEmr->cbBmi){
+      printf("      bitmap:");
+      bitmapinfo_print(contents + pEmr->offBmi, blimit);
+      printf("\n");
+   }
+   printf("   offBits:      %u\n",pEmr->offBits );
+   printf("   cbBits :      %u\n",pEmr->cbBits  );
+}
+
+// common code for U_EMRALPHABLEND_print and U_EMRTRANSPARENTBLT_print,
+void core13_print(const char *name, const char *contents){
+   UNUSED(name);
+   PU_EMRALPHABLEND pEmr = (PU_EMRALPHABLEND) (contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRALPHABLEND)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");    rectl_print( pEmr->rclBounds);       printf("\n");
+   printf("   Dest:           ");    pointl_print(pEmr->Dest);            printf("\n");
+   printf("   cDest:          ");    pointl_print(pEmr->cDest);           printf("\n");
+   printf("   Blend:          ");    blend_print(pEmr->Blend);            printf("\n");
+   printf("   Src:            ");    pointl_print(pEmr->Src);             printf("\n");
+   printf("   xformSrc:       ");    xform_print( pEmr->xformSrc);        printf("\n");
+   printf("   crBkColorSrc:   ");    colorref_print( pEmr->crBkColorSrc); printf("\n");
+   printf("   iUsageSrc:      %u\n",pEmr->iUsageSrc   );
+   printf("   offBmiSrc:      %u\n",pEmr->offBmiSrc   );
+   printf("   cbBmiSrc:       %u\n",pEmr->cbBmiSrc    );
+   if(pEmr->cbBmiSrc){
+      printf("      bitmap:");
+      bitmapinfo_print(contents + pEmr->offBmiSrc, blimit);
+      printf("\n");
+   }
+   printf("   offBitsSrc:     %u\n",pEmr->offBitsSrc  );
+   printf("   cbBitsSrc:      %u\n",pEmr->cbBitsSrc   );
+}
+//! @endcond
+
+/* **********************************************************************************************
+These are the core EMR functions, each creates a particular type of record.  
+All return these records via a char* pointer, which is NULL if the call failed.  
+They are listed in order by the corresponding U_EMR_* index number.  
+*********************************************************************************************** */
+
+/**
+    \brief Print a pointer to a U_EMR_whatever record which has not been implemented.
+    \param name       name of this type of record
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRNOTIMPLEMENTED_print(const char *name, const char *contents){
+   UNUSED(name);
+   UNUSED(contents);
+   printf("   Not Implemented!\n");
+}
+
+// U_EMRHEADER                1
+/**
+    \brief Print a pointer to a U_EMR_HEADER record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRHEADER_print(const char *contents){
+   char *string;
+   int  p1len;
+
+   PU_EMRHEADER pEmr = (PU_EMRHEADER)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRHEADER)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");          rectl_print( pEmr->rclBounds);   printf("\n");
+   printf("   rclFrame:       ");          rectl_print( pEmr->rclFrame);    printf("\n");
+   printf("   dSignature:     0x%8.8X\n",  pEmr->dSignature    );
+   printf("   nVersion:       0x%8.8X\n",  pEmr->nVersion      );
+   printf("   nBytes:         %d\n",       pEmr->nBytes        );
+   printf("   nRecords:       %d\n",       pEmr->nRecords      );
+   printf("   nHandles:       %d\n",       pEmr->nHandles      );
+   printf("   sReserved:      %d\n",       pEmr->sReserved     );
+   printf("   nDescription:   %d\n",       pEmr->nDescription  );
+   printf("   offDescription: %d\n",       pEmr->offDescription);
+   if(pEmr->offDescription){
+      IF_MEM_UNSAFE_PRINT_AND_RETURN(contents, pEmr->offDescription + pEmr->nDescription*2*sizeof(char), blimit);
+      string = U_Utf16leToUtf8((uint16_t *)((char *) pEmr + pEmr->offDescription), pEmr->nDescription, NULL);
+      printf("      Desc. A:  %s\n",string);
+      free(string);
+      p1len = 2 + 2*wchar16len((uint16_t *)((char *) pEmr + pEmr->offDescription));
+      string = U_Utf16leToUtf8((uint16_t *)((char *) pEmr + pEmr->offDescription + p1len), pEmr->nDescription, NULL);
+      printf("      Desc. B:  %s\n",string);
+      free(string);
+   }
+   printf("   nPalEntries:    %d\n",       pEmr->nPalEntries   );
+   printf("   szlDevice:      {%d,%d} \n", pEmr->szlDevice.cx,pEmr->szlDevice.cy);
+   printf("   szlMillimeters: {%d,%d} \n", pEmr->szlMillimeters.cx,pEmr->szlMillimeters.cy);
+   if((pEmr->nDescription && (pEmr->offDescription >= 100)) || 
+      (!pEmr->offDescription && pEmr->emr.nSize >= 100)
+     ){
+      printf("   cbPixelFormat:  %d\n",       pEmr->cbPixelFormat );
+      printf("   offPixelFormat: %d\n",       pEmr->offPixelFormat);
+      if(pEmr->cbPixelFormat){
+         printf("      PFD:");
+         IF_MEM_UNSAFE_PRINT_AND_RETURN(contents, pEmr->offPixelFormat + sizeof(U_PIXELFORMATDESCRIPTOR), blimit);
+         pixelformatdescriptor_print( *(PU_PIXELFORMATDESCRIPTOR) (contents + pEmr->offPixelFormat));
+         printf("\n");
+      }
+      printf("   bOpenGL:        %d\n",pEmr->bOpenGL       );
+      if((pEmr->nDescription    && (pEmr->offDescription >= 108)) || 
+              (pEmr->cbPixelFormat   && (pEmr->offPixelFormat >=108)) ||
+              (!pEmr->offDescription && !pEmr->cbPixelFormat && pEmr->emr.nSize >= 108)
+             ){
+         printf("   szlMicrometers: {%d,%d} \n", pEmr->szlMicrometers.cx,pEmr->szlMicrometers.cy);
+     }
+   }
+}
+
+// U_EMRPOLYBEZIER                       2
+/**
+    \brief Print a pointer to a U_EMR_POLYBEZIER record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPOLYBEZIER_print(const char *contents){
+   core1_print("U_EMRPOLYBEZIER", contents);
+} 
+
+// U_EMRPOLYGON                          3
+/**
+    \brief Print a pointer to a U_EMR_POLYGON record.
+    \param contents   pointer to a buffer holding all EMR records
+ */
+void U_EMRPOLYGON_print(const char *contents){
+   core1_print("U_EMRPOLYGON", contents);
+} 
+
+
+// U_EMRPOLYLINE              4
+/**
+    \brief Print a pointer to a U_EMR_POLYLINE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPOLYLINE_print(const char *contents){
+   core1_print("U_EMRPOLYLINE", contents);
+} 
+
+// U_EMRPOLYBEZIERTO          5
+/**
+    \brief Print a pointer to a U_EMR_POLYBEZIERTO record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPOLYBEZIERTO_print(const char *contents){
+   core1_print("U_EMRPOLYBEZIERTO", contents);
+} 
+
+// U_EMRPOLYLINETO            6
+/**
+    \brief Print a pointer to a U_EMR_POLYLINETO record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPOLYLINETO_print(const char *contents){
+   core1_print("U_EMRPOLYLINETO", contents);
+} 
+
+// U_EMRPOLYPOLYLINE          7
+/**
+    \brief Print a pointer to a U_EMR_POLYPOLYLINE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPOLYPOLYLINE_print(const char *contents){
+   core2_print("U_EMRPOLYPOLYLINE", contents);
+} 
+
+// U_EMRPOLYPOLYGON           8
+/**
+    \brief Print a pointer to a U_EMR_POLYPOLYGON record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPOLYPOLYGON_print(const char *contents){
+   core2_print("U_EMRPOLYPOLYGON", contents);
+} 
+
+// U_EMRSETWINDOWEXTEX        9
+/**
+    \brief Print a pointer to a U_EMR_SETWINDOWEXTEX record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETWINDOWEXTEX_print(const char *contents){
+   core7_print("U_EMRSETWINDOWEXTEX", "szlExtent:","",contents);
+} 
+
+// U_EMRSETWINDOWORGEX       10
+/**
+    \brief Print a pointer to a U_EMR_SETWINDOWORGEX record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETWINDOWORGEX_print(const char *contents){
+   core7_print("U_EMRSETWINDOWORGEX", "ptlOrigin:","",contents);
+} 
+
+// U_EMRSETVIEWPORTEXTEX     11
+/**
+    \brief Print a pointer to a U_EMR_SETVIEWPORTEXTEX record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETVIEWPORTEXTEX_print(const char *contents){
+   core7_print("U_EMRSETVIEWPORTEXTEX", "szlExtent:","",contents);
+} 
+
+// U_EMRSETVIEWPORTORGEX     12
+/**
+    \brief Print a pointer to a U_EMR_SETVIEWPORTORGEX record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETVIEWPORTORGEX_print(const char *contents){
+   core7_print("U_EMRSETVIEWPORTORGEX", "ptlOrigin:","",contents);
+} 
+
+// U_EMRSETBRUSHORGEX        13
+/**
+    \brief Print a pointer to a U_EMR_SETBRUSHORGEX record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETBRUSHORGEX_print(const char *contents){
+   core7_print("U_EMRSETBRUSHORGEX", "ptlOrigin:","",contents);
+} 
+
+// U_EMREOF                  14
+/**
+    \brief Print a pointer to a U_EMR_EOF record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMREOF_print(const char *contents){
+   PU_EMREOF pEmr = (PU_EMREOF)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMREOF)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   printf("   cbPalEntries:   %u\n",      pEmr->cbPalEntries );
+   printf("   offPalEntries:  %u\n",      pEmr->offPalEntries);
+   if(pEmr->cbPalEntries){
+     printf("      PE:");
+     logpalette_print( (PU_LOGPALETTE)(contents + pEmr->offPalEntries));
+     printf("\n");
+   }
+} 
+
+
+// U_EMRSETPIXELV            15
+/**
+    \brief Print a pointer to a U_EMR_SETPIXELV record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETPIXELV_print(const char *contents){
+   PU_EMRSETPIXELV pEmr = (PU_EMRSETPIXELV)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRSETPIXELV)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   printf("   ptlPixel:       ");  pointl_print(  pEmr->ptlPixel);  printf("\n");
+   printf("   crColor:        ");  colorref_print(pEmr->crColor);   printf("\n");
+} 
+
+
+// U_EMRSETMAPPERFLAGS       16
+/**
+    \brief Print a pointer to a U_EMR_SETMAPPERFLAGS record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETMAPPERFLAGS_print(const char *contents){
+   PU_EMRSETMAPPERFLAGS pEmr = (PU_EMRSETMAPPERFLAGS)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRSETMAPPERFLAGS)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   printf("   dwFlags:        0x%8.8X\n",pEmr->dwFlags);
+} 
+
+
+// U_EMRSETMAPMODE           17
+/**
+    \brief Print a pointer to a U_EMR_SETMAPMODE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETMAPMODE_print(const char *contents){
+   core3_print("U_EMRSETMAPMODE", "iMode:", contents);
+}
+
+// U_EMRSETBKMODE            18
+/**
+    \brief Print a pointer to a U_EMR_SETBKMODE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETBKMODE_print(const char *contents){
+   core3_print("U_EMRSETBKMODE", "iMode:", contents);
+}
+
+// U_EMRSETPOLYFILLMODE      19
+/**
+    \brief Print a pointer to a U_EMR_SETPOLYFILLMODE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETPOLYFILLMODE_print(const char *contents){
+   core3_print("U_EMRSETPOLYFILLMODE", "iMode:", contents);
+}
+
+// U_EMRSETROP2              20
+/**
+    \brief Print a pointer to a U_EMR_SETROP2 record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETROP2_print(const char *contents){
+   core3_print("U_EMRSETROP2", "dwRop:", contents);
+}
+
+// U_EMRSETSTRETCHBLTMODE    21
+/**
+    \brief Print a pointer to a U_EMR_SETSTRETCHBLTMODE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETSTRETCHBLTMODE_print(const char *contents){
+   core3_print("U_EMRSETSTRETCHBLTMODE", "iMode:", contents);
+}
+
+// U_EMRSETTEXTALIGN         22
+/**
+    \brief Print a pointer to a U_EMR_SETTEXTALIGN record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETTEXTALIGN_print(const char *contents){
+   core3_print("U_EMRSETTEXTALIGN", "iMode:", contents);
+}
+
+// U_EMRSETCOLORADJUSTMENT   23
+/**
+    \brief Print a pointer to a U_EMR_SETCOLORADJUSTMENT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETCOLORADJUSTMENT_print(const char *contents){
+   PU_EMRSETCOLORADJUSTMENT pEmr = (PU_EMRSETCOLORADJUSTMENT)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRSETCOLORADJUSTMENT)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   printf("   ColorAdjustment:");
+   coloradjustment_print(pEmr->ColorAdjustment);
+   printf("\n");
+}
+
+// U_EMRSETTEXTCOLOR         24
+/**
+    \brief Print a pointer to a U_EMR_SETTEXTCOLOR record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETTEXTCOLOR_print(const char *contents){
+   core3_print("U_EMRSETTEXTCOLOR", "crColor:", contents);
+}
+
+// U_EMRSETBKCOLOR           25
+/**
+    \brief Print a pointer to a U_EMR_SETBKCOLOR record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETBKCOLOR_print(const char *contents){
+   core3_print("U_EMRSETBKCOLOR", "crColor:", contents);
+}
+
+// U_EMROFFSETCLIPRGN        26
+/**
+    \brief Print a pointer to a U_EMR_OFFSETCLIPRGN record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMROFFSETCLIPRGN_print(const char *contents){
+   core7_print("U_EMROFFSETCLIPRGN", "ptl:","",contents);
+} 
+
+// U_EMRMOVETOEX             27
+/**
+    \brief Print a pointer to a U_EMR_MOVETOEX record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRMOVETOEX_print(const char *contents){
+   core7_print("U_EMRMOVETOEX", "ptl:","",contents);
+} 
+
+// U_EMRSETMETARGN           28
+/**
+    \brief Print a pointer to a U_EMR_SETMETARGN record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETMETARGN_print(const char *contents){
+   UNUSED(contents);
+}
+
+// U_EMREXCLUDECLIPRECT      29
+/**
+    \brief Print a pointer to a U_EMR_EXCLUDECLIPRECT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMREXCLUDECLIPRECT_print(const char *contents){
+   core4_print("U_EMREXCLUDECLIPRECT", contents);
+}
+
+// U_EMRINTERSECTCLIPRECT    30
+/**
+    \brief Print a pointer to a U_EMR_INTERSECTCLIPRECT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRINTERSECTCLIPRECT_print(const char *contents){
+   core4_print("U_EMRINTERSECTCLIPRECT", contents);
+}
+
+// U_EMRSCALEVIEWPORTEXTEX   31
+/**
+    \brief Print a pointer to a U_EMR_SCALEVIEWPORTEXTEX record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSCALEVIEWPORTEXTEX_print(const char *contents){
+   core4_print("U_EMRSCALEVIEWPORTEXTEX", contents);
+}
+
+
+// U_EMRSCALEWINDOWEXTEX     32
+/**
+    \brief Print a pointer to a U_EMR_SCALEWINDOWEXTEX record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSCALEWINDOWEXTEX_print(const char *contents){
+   core4_print("U_EMRSCALEWINDOWEXTEX", contents);
+}
+
+// U_EMRSAVEDC               33
+/**
+    \brief Print a pointer to a U_EMR_SAVEDC record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSAVEDC_print(const char *contents){
+   UNUSED(contents);
+}
+
+// U_EMRRESTOREDC            34
+/**
+    \brief Print a pointer to a U_EMR_RESTOREDC record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRRESTOREDC_print(const char *contents){
+   core3_print("U_EMRRESTOREDC", "iRelative:", contents);
+}
+
+// U_EMRSETWORLDTRANSFORM    35
+/**
+    \brief Print a pointer to a U_EMR_SETWORLDTRANSFORM record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETWORLDTRANSFORM_print(const char *contents){
+   PU_EMRSETWORLDTRANSFORM pEmr = (PU_EMRSETWORLDTRANSFORM)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRSETWORLDTRANSFORM)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   printf("   xform:");
+   xform_print(pEmr->xform);
+   printf("\n");
+} 
+
+// U_EMRMODIFYWORLDTRANSFORM 36
+/**
+    \brief Print a pointer to a U_EMR_MODIFYWORLDTRANSFORM record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRMODIFYWORLDTRANSFORM_print(const char *contents){
+   PU_EMRMODIFYWORLDTRANSFORM pEmr = (PU_EMRMODIFYWORLDTRANSFORM)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRMODIFYWORLDTRANSFORM)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   printf("   xform:");
+   xform_print(pEmr->xform);
+   printf("\n");
+   printf("   iMode:          %u\n",      pEmr->iMode );
+} 
+
+// U_EMRSELECTOBJECT         37
+/**
+    \brief Print a pointer to a U_EMR_SELECTOBJECT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSELECTOBJECT_print(const char *contents){
+   PU_EMRSELECTOBJECT pEmr = (PU_EMRSELECTOBJECT)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRSELECTOBJECT)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   if(pEmr->ihObject & U_STOCK_OBJECT){
+     printf("   StockObject:    0x%8.8X\n",  pEmr->ihObject );
+   }
+   else {
+     printf("   ihObject:       %u\n",     pEmr->ihObject );
+   }
+} 
+
+// U_EMRCREATEPEN            38
+/**
+    \brief Print a pointer to a U_EMR_CREATEPEN record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRCREATEPEN_print(const char *contents){
+   PU_EMRCREATEPEN pEmr = (PU_EMRCREATEPEN)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRCREATEPEN)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   printf("   ihPen:          %u\n",      pEmr->ihPen );
+   printf("   lopn:           ");    logpen_print(pEmr->lopn);  printf("\n");
+} 
+
+// U_EMRCREATEBRUSHINDIRECT  39
+/**
+    \brief Print a pointer to a U_EMR_CREATEBRUSHINDIRECT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRCREATEBRUSHINDIRECT_print(const char *contents){
+   PU_EMRCREATEBRUSHINDIRECT pEmr = (PU_EMRCREATEBRUSHINDIRECT)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRCREATEBRUSHINDIRECT)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   printf("   ihBrush:        %u\n",      pEmr->ihBrush );
+   printf("   lb:             ");         logbrush_print(pEmr->lb);  printf("\n");
+} 
+
+// U_EMRDELETEOBJECT         40
+/**
+    \brief Print a pointer to a U_EMR_DELETEOBJECT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRDELETEOBJECT_print(const char *contents){
+   PU_EMRDELETEOBJECT pEmr = (PU_EMRDELETEOBJECT)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRDELETEOBJECT)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   printf("   ihObject:       %u\n",      pEmr->ihObject );
+} 
+
+// U_EMRANGLEARC             41
+/**
+    \brief Print a pointer to a U_EMR_ANGLEARC record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRANGLEARC_print(const char *contents){
+   PU_EMRANGLEARC pEmr = (PU_EMRANGLEARC)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRANGLEARC)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   printf("   ptlCenter:      "), pointl_print(pEmr->ptlCenter ); printf("\n");
+   printf("   nRadius:        %u\n",      pEmr->nRadius );
+   printf("   eStartAngle:    %f\n",       pEmr->eStartAngle );
+   printf("   eSweepAngle:    %f\n",       pEmr->eSweepAngle );
+} 
+
+// U_EMRELLIPSE              42
+/**
+    \brief Print a pointer to a U_EMR_ELLIPSE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRELLIPSE_print(const char *contents){
+   core4_print("U_EMRELLIPSE", contents);
+}
+
+// U_EMRRECTANGLE            43
+/**
+    \brief Print a pointer to a U_EMR_RECTANGLE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRRECTANGLE_print(const char *contents){
+   core4_print("U_EMRRECTANGLE", contents);
+}
+
+// U_EMRROUNDRECT            44
+/**
+    \brief Print a pointer to a U_EMR_ROUNDRECT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRROUNDRECT_print(const char *contents){
+   PU_EMRROUNDRECT pEmr = (PU_EMRROUNDRECT)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRROUNDRECT)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   printf("   rclBox:         "), rectl_print(pEmr->rclBox );     printf("\n");
+   printf("   szlCorner:      "), sizel_print(pEmr->szlCorner );  printf("\n");
+}
+
+// U_EMRARC                  45
+/**
+    \brief Print a pointer to a U_EMR_ARC record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRARC_print(const char *contents){
+   core9_print("U_EMRARC", contents);
+}
+
+// U_EMRCHORD                46
+/**
+    \brief Print a pointer to a U_EMR_CHORD record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRCHORD_print(const char *contents){
+   core9_print("U_EMRCHORD", contents);
+}
+
+// U_EMRPIE                  47
+/**
+    \brief Print a pointer to a U_EMR_PIE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPIE_print(const char *contents){
+   core9_print("U_EMRPIE", contents);
+}
+
+// U_EMRSELECTPALETTE        48
+/**
+    \brief Print a pointer to a U_EMR_SELECTPALETTE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSELECTPALETTE_print(const char *contents){
+   core3_print("U_EMRSELECTPALETTE", "ihPal:", contents);
+}
+
+// U_EMRCREATEPALETTE        49
+/**
+    \brief Print a pointer to a U_EMR_CREATEPALETTE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRCREATEPALETTE_print(const char *contents){
+   PU_EMRCREATEPALETTE pEmr = (PU_EMRCREATEPALETTE)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRCREATEPALETTE)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   printf("   ihPal:          %u\n",pEmr->ihPal);
+   printf("   lgpl:           "), logpalette_print( (PU_LOGPALETTE)&(pEmr->lgpl) );  printf("\n");
+}
+
+// U_EMRSETPALETTEENTRIES    50
+/**
+    \brief Print a pointer to a U_EMR_SETPALETTEENTRIES record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETPALETTEENTRIES_print(const char *contents){
+   unsigned int i;
+   PU_EMRSETPALETTEENTRIES pEmr = (PU_EMRSETPALETTEENTRIES)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRSETPALETTEENTRIES)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   ihPal:          %u\n",pEmr->ihPal);
+   printf("   iStart:         %u\n",pEmr->iStart);
+   printf("   cEntries:       %u\n",pEmr->cEntries);
+   if(pEmr->cEntries){
+      printf("      PLTEntries:");
+      PU_LOGPLTNTRY aPalEntries = (PU_LOGPLTNTRY) &(pEmr->aPalEntries);
+      IF_MEM_UNSAFE_PRINT_AND_RETURN(aPalEntries, pEmr->cEntries*sizeof(U_LOGPLTNTRY), blimit);
+      for(i=0; i<pEmr->cEntries; i++){
+         printf("%d:",i); logpltntry_print(aPalEntries[i]);
+      }
+      printf("\n");
+   }
+}
+
+// U_EMRRESIZEPALETTE        51
+/**
+    \brief Print a pointer to a U_EMR_RESIZEPALETTE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRRESIZEPALETTE_print(const char *contents){
+   core7_print("U_EMRRESIZEPALETTE", "ihPal:","cEntries",contents);
+} 
+
+// U_EMRREALIZEPALETTE       52
+/**
+    \brief Print a pointer to a U_EMR_REALIZEPALETTE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRREALIZEPALETTE_print(const char *contents){
+   UNUSED(contents);
+}
+
+// U_EMREXTFLOODFILL         53
+/**
+    \brief Print a pointer to a U_EMR_EXTFLOODFILL record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMREXTFLOODFILL_print(const char *contents){
+   PU_EMREXTFLOODFILL pEmr = (PU_EMREXTFLOODFILL)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMREXTFLOODFILL)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   printf("   ptlStart:       ");   pointl_print(pEmr->ptlStart);    printf("\n");
+   printf("   crColor:        ");   colorref_print(pEmr->crColor);   printf("\n");
+   printf("   iMode:          %u\n",pEmr->iMode);
+}
+
+// U_EMRLINETO               54
+/**
+    \brief Print a pointer to a U_EMR_LINETO record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRLINETO_print(const char *contents){
+   core7_print("U_EMRLINETO", "ptl:","",contents);
+} 
+
+// U_EMRARCTO                55
+/**
+    \brief Print a pointer to a U_EMR_ARCTO record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRARCTO_print(const char *contents){
+   core9_print("U_EMRARCTO", contents);
+}
+
+// U_EMRPOLYDRAW             56
+/**
+    \brief Print a pointer to a U_EMR_POLYDRAW record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPOLYDRAW_print(const char *contents){
+   unsigned int i;
+   PU_EMRPOLYDRAW pEmr = (PU_EMRPOLYDRAW)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRPOLYDRAW)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");          rectl_print( pEmr->rclBounds);   printf("\n");
+   printf("   cptl:           %d\n",pEmr->cptl        );
+   printf("   Points:         ");
+   IF_MEM_UNSAFE_PRINT_AND_RETURN(pEmr->aptl, pEmr->cptl*sizeof(U_POINTL), blimit);
+   for(i=0;i<pEmr->cptl; i++){
+      printf(" [%d]:",i);
+      pointl_print(pEmr->aptl[i]);
+   }
+   printf("\n");
+   printf("   Types:          ");
+   const char *abTypes = (const char *) pEmr->aptl + pEmr->cptl*sizeof(U_POINTL);
+   IF_MEM_UNSAFE_PRINT_AND_RETURN(abTypes, pEmr->cptl, blimit);
+   for(i=0;i<pEmr->cptl; i++){
+      printf(" [%d]:%u ",i,((uint8_t *)abTypes)[i]);
+   }
+   printf("\n");
+}
+
+// U_EMRSETARCDIRECTION      57
+/**
+    \brief Print a pointer to a U_EMR_SETARCDIRECTION record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETARCDIRECTION_print(const char *contents){
+   core3_print("U_EMRSETARCDIRECTION","arcDirection:", contents);
+}
+
+// U_EMRSETMITERLIMIT        58
+/**
+    \brief Print a pointer to a U_EMR_SETMITERLIMIT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETMITERLIMIT_print(const char *contents){
+   core3_print("U_EMRSETMITERLIMIT", "eMiterLimit:", contents);
+}
+
+
+// U_EMRBEGINPATH            59
+/**
+    \brief Print a pointer to a U_EMR_BEGINPATH record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRBEGINPATH_print(const char *contents){
+   UNUSED(contents);
+}
+
+// U_EMRENDPATH              60
+/**
+    \brief Print a pointer to a U_EMR_ENDPATH record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRENDPATH_print(const char *contents){
+   UNUSED(contents);
+}
+
+// U_EMRCLOSEFIGURE          61
+/**
+    \brief Print a pointer to a U_EMR_CLOSEFIGURE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRCLOSEFIGURE_print(const char *contents){
+   UNUSED(contents);
+}
+
+// U_EMRFILLPATH             62
+/**
+    \brief Print a pointer to a U_EMR_FILLPATH record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRFILLPATH_print(const char *contents){
+   core4_print("U_EMRFILLPATH", contents);
+}
+
+// U_EMRSTROKEANDFILLPATH    63
+/**
+    \brief Print a pointer to a U_EMR_STROKEANDFILLPATH record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSTROKEANDFILLPATH_print(const char *contents){
+   core4_print("U_EMRSTROKEANDFILLPATH", contents);
+}
+
+// U_EMRSTROKEPATH           64
+/**
+    \brief Print a pointer to a U_EMR_STROKEPATH record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSTROKEPATH_print(const char *contents){
+   core4_print("U_EMRSTROKEPATH", contents);
+}
+
+// U_EMRFLATTENPATH          65
+/**
+    \brief Print a pointer to a U_EMR_FLATTENPATH record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRFLATTENPATH_print(const char *contents){
+   UNUSED(contents);
+}
+
+// U_EMRWIDENPATH            66
+/**
+    \brief Print a pointer to a U_EMR_WIDENPATH record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRWIDENPATH_print(const char *contents){
+   UNUSED(contents);
+}
+
+// U_EMRSELECTCLIPPATH       67
+/**
+    \brief Print a pointer to a U_EMR_SELECTCLIPPATH record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSELECTCLIPPATH_print(const char *contents){
+   core3_print("U_EMRSELECTCLIPPATH", "iMode:", contents);
+}
+
+// U_EMRABORTPATH            68
+/**
+    \brief Print a pointer to a U_EMR_ABORTPATH record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRABORTPATH_print(const char *contents){
+   UNUSED(contents);
+}
+
+// U_EMRUNDEF69                       69
+#define U_EMRUNDEF69_print(A) U_EMRNOTIMPLEMENTED_print("U_EMRUNDEF69",A) //!< Not implemented.
+
+// U_EMRCOMMENT              70  Comment (any binary data, interpretation is program specific)
+/**
+    \brief Print a pointer to a U_EMR_COMMENT record.
+    \param contents   pointer to a location in memory holding the comment record
+    \param off        offset in bytes to the first byte in this record (needed for EMF+ record printing)
+
+    EMF+ records, if any, are stored in EMF comment records.
+*/
+void U_EMRCOMMENT_print(const char *contents, size_t off){
+   char *string;
+   char *src;
+   uint32_t cIdent,cIdent2,cbData;
+   size_t loff;
+   int    recsize;
+   static int recnum=0;
+
+   PU_EMRCOMMENT pEmr = (PU_EMRCOMMENT)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRCOMMENT)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+
+   /* There are several different types of comments */
+
+   IF_MEM_UNSAFE_PRINT_AND_RETURN(contents, sizeof(U_EMRCOMMENT), blimit);
+   cbData = pEmr->cbData;
+   printf("   cbData:         %d\n",cbData        );
+   IF_MEM_UNSAFE_PRINT_AND_RETURN(contents, sizeof(U_EMR) + sizeof(U_CBDATA) + cbData, blimit);
+   src = (char *)&(pEmr->Data);  // default
+   if(cbData >= 4){
+      /* Since the comment is just a big bag of bytes the emf endian code cannot safely touch
+         any of its payload.  This is the only record type with that limitation.  So the record
+         may appear at this stage with the wrong endianness.  Try to determine
+	 what the contents are even if more byte swapping is required. */
+      cIdent = *(uint32_t *)(src);
+      if(U_BYTE_SWAP){ U_swap4(&(cIdent),1); }
+      if(     cIdent == U_EMR_COMMENT_PUBLIC       ){
+         printf("   cIdent:  Public\n");
+         PU_EMRCOMMENT_PUBLIC pEmrp = (PU_EMRCOMMENT_PUBLIC) pEmr;
+         IF_MEM_UNSAFE_PRINT_AND_RETURN(contents, sizeof(U_EMRCOMMENT_PUBLIC), blimit);
+	 cIdent2 = pEmrp->pcIdent;
+         if(U_BYTE_SWAP){ U_swap4(&(cIdent2),1); }
+         printf("   pcIdent:        0x%8.8x\n",cIdent2);
+         src = (char *)&(pEmrp->Data);
+         cbData -= 8;
+      }
+      else if(cIdent == U_EMR_COMMENT_SPOOL        ){
+         printf("   cIdent:  Spool\n");
+         PU_EMRCOMMENT_SPOOL pEmrs = (PU_EMRCOMMENT_SPOOL) pEmr;
+         IF_MEM_UNSAFE_PRINT_AND_RETURN(contents, sizeof(U_EMRCOMMENT_SPOOL), blimit);
+	 cIdent2 = pEmrs->esrIdent;
+         if(U_BYTE_SWAP){ U_swap4(&(cIdent2),1); }
+         printf("   esrIdent:       0x%8.8x\n",cIdent2);
+         src = (char *)&(pEmrs->Data);
+         cbData -= 8;
+      }
+      else if(cIdent == U_EMR_COMMENT_EMFPLUSRECORD){
+         printf("   cIdent:  EMF+\n");
+         PU_EMRCOMMENT_EMFPLUS pEmrpl = (PU_EMRCOMMENT_EMFPLUS) pEmr;
+         IF_MEM_UNSAFE_PRINT_AND_RETURN(contents, sizeof(U_EMRCOMMENT_EMFPLUS), blimit);
+         src = (char *)&(pEmrpl->Data);
+         loff = 16;  /* Header size of the header part of an EMF+ comment record */
+         while(loff < cbData + 12){  // EMF+ records may not fill the entire comment, cbData value includes cIdent, but not U_EMR or cbData
+            recsize =  U_pmf_onerec_print(src, blimit, recnum, loff + off);
+            if(recsize==0){ break; }
+            else if(recsize<0){
+               printf("   record corruption HERE\n");
+               return;
+            }
+            loff += recsize;
+            src  += recsize;
+            recnum++;
+         }
+         return;
+      }
+      else {
+         printf("   cIdent:         not (Public or Spool or EMF+)\n");
+      }
+   }
+   if(cbData){ // The data may not be printable, but try it just in case
+      string = malloc(cbData + 1);
+      (void)strncpy(string, src, cbData);
+      string[cbData] = '\0'; // it might not be terminated - it might not even be text!
+      printf("   Data:           <%s>\n",string);
+      free(string);
+   }
+} 
+
+// U_EMRFILLRGN              71
+/**
+    \brief Print a pointer to a U_EMR_FILLRGN record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRFILLRGN_print(const char *contents){
+   PU_EMRFILLRGN pEmr = (PU_EMRFILLRGN)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRFILLRGN)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");    rectl_print(pEmr->rclBounds);    printf("\n");
+   printf("   cbRgnData:      %u\n",pEmr->cbRgnData);
+   printf("   ihBrush:        %u\n",pEmr->ihBrush);
+   const char *minptr = MAKE_MIN_PTR(((const char *) &pEmr->RgnData + pEmr->cbRgnData + sizeof(U_RGNDATAHEADER)),blimit);
+   printf("   RegionData: "); rgndata_print(pEmr->RgnData, minptr); printf("\n");
+} 
+
+// U_EMRFRAMERGN             72
+/**
+    \brief Print a pointer to a U_EMR_FRAMERGN record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRFRAMERGN_print(const char *contents){
+   PU_EMRFRAMERGN pEmr = (PU_EMRFRAMERGN)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRFRAMERGN)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");    rectl_print(pEmr->rclBounds);    printf("\n");
+   printf("   cbRgnData:      %u\n",pEmr->cbRgnData);
+   printf("   ihBrush:        %u\n",pEmr->ihBrush);
+   printf("   szlStroke:      "), sizel_print(pEmr->szlStroke );      printf("\n");
+   const char *minptr = MAKE_MIN_PTR(((const char *) &pEmr->RgnData + pEmr->cbRgnData),blimit);
+   printf("   RegionData: "); rgndata_print(pEmr->RgnData, minptr); printf("\n");
+} 
+
+// U_EMRINVERTRGN            73
+/**
+    \brief Print a pointer to a U_EMR_INVERTRGN record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRINVERTRGN_print(const char *contents){
+   core11_print("U_EMRINVERTRGN", contents);
+}
+
+// U_EMRPAINTRGN             74
+/**
+    \brief Print a pointer to a U_EMR_PAINTRGN record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPAINTRGN_print(const char *contents){
+   core11_print("U_EMRPAINTRGN", contents);
+}
+
+// U_EMREXTSELECTCLIPRGN     75
+/**
+    \brief Print a pointer to a U_EMR_EXTSELECTCLIPRGN record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMREXTSELECTCLIPRGN_print(const char *contents){
+   PU_EMREXTSELECTCLIPRGN pEmr = (PU_EMREXTSELECTCLIPRGN) (contents);
+   if(pEmr->emr.nSize < U_SIZE_EMREXTSELECTCLIPRGN){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   cbRgnData:      %u\n",pEmr->cbRgnData);
+   printf("   iMode:          %u\n",pEmr->iMode);
+   if(pEmr->iMode == U_RGN_COPY && !pEmr->cbRgnData){
+      printf("   RegionData: none (Clip region becomes NULL)\n");
+   }
+   else {
+      const char *minptr = MAKE_MIN_PTR(((const char *) &pEmr->RgnData + pEmr->cbRgnData),blimit);
+      printf("   RegionData: "); rgndata_print(pEmr->RgnData, minptr); printf("\n");
+   }
+
+} 
+
+// U_EMRBITBLT               76
+/**
+    \brief Print a pointer to a U_EMR_BITBLT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRBITBLT_print(const char *contents){
+   PU_EMRBITBLT pEmr = (PU_EMRBITBLT) (contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRBITBLT)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");     rectl_print( pEmr->rclBounds);       printf("\n");
+   printf("   Dest:           ");     pointl_print(pEmr->Dest);            printf("\n");
+   printf("   cDest:          ");     pointl_print(pEmr->cDest);           printf("\n");
+   printf("   dwRop :         0x%8.8X\n", pEmr->dwRop   );
+   printf("   Src:            ");     pointl_print(pEmr->Src);             printf("\n");
+   printf("   xformSrc:       ");     xform_print( pEmr->xformSrc);        printf("\n");
+   printf("   crBkColorSrc:   ");     colorref_print( pEmr->crBkColorSrc); printf("\n");
+   printf("   iUsageSrc:      %u\n", pEmr->iUsageSrc   );
+   printf("   offBmiSrc:      %u\n", pEmr->offBmiSrc   );
+   printf("   cbBmiSrc:       %u\n", pEmr->cbBmiSrc    );
+   if(pEmr->cbBmiSrc){
+      printf("      bitmap:      ");
+      bitmapinfo_print(contents + pEmr->offBmiSrc, blimit);
+      printf("\n");
+   }
+   printf("   offBitsSrc:     %u\n", pEmr->offBitsSrc   );
+   printf("   cbBitsSrc:      %u\n", pEmr->cbBitsSrc    );
+}
+
+// U_EMRSTRETCHBLT           77
+/**
+    \brief Print a pointer to a U_EMR_STRETCHBLT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSTRETCHBLT_print(const char *contents){
+   PU_EMRSTRETCHBLT pEmr = (PU_EMRSTRETCHBLT) (contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRSTRETCHBLT)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");     rectl_print( pEmr->rclBounds);       printf("\n");
+   printf("   Dest:           ");     pointl_print(pEmr->Dest);            printf("\n");
+   printf("   cDest:          ");     pointl_print(pEmr->cDest);           printf("\n");
+   printf("   dwRop :         0x%8.8X\n", pEmr->dwRop   );
+   printf("   Src:            ");     pointl_print(pEmr->Src);             printf("\n");
+   printf("   xformSrc:       ");     xform_print( pEmr->xformSrc);        printf("\n");
+   printf("   crBkColorSrc:   ");     colorref_print( pEmr->crBkColorSrc); printf("\n");
+   printf("   iUsageSrc:      %u\n", pEmr->iUsageSrc   );
+   printf("   offBmiSrc:      %u\n", pEmr->offBmiSrc   );
+   printf("   cbBmiSrc:       %u\n", pEmr->cbBmiSrc    );
+   if(pEmr->cbBmiSrc){
+      printf("      bitmap:      ");
+      bitmapinfo_print(contents + pEmr->offBmiSrc, blimit);
+      printf("\n");
+   }
+   printf("   offBitsSrc:     %u\n", pEmr->offBitsSrc   );
+   printf("   cbBitsSrc:      %u\n", pEmr->cbBitsSrc    );
+   printf("   cSrc:           ");     pointl_print(pEmr->cSrc);            printf("\n");
+}
+
+// U_EMRMASKBLT              78
+/**
+    \brief Print a pointer to a U_EMR_MASKBLT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRMASKBLT_print(const char *contents){
+   PU_EMRMASKBLT pEmr = (PU_EMRMASKBLT) (contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRMASKBLT)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");     rectl_print( pEmr->rclBounds);       printf("\n");
+   printf("   Dest:           ");     pointl_print(pEmr->Dest);            printf("\n");
+   printf("   cDest:          ");     pointl_print(pEmr->cDest);           printf("\n");
+   printf("   dwRop :         0x%8.8X\n",  pEmr->dwRop   );
+   printf("   Src:            ");     pointl_print(pEmr->Src);             printf("\n");
+   printf("   xformSrc:       ");     xform_print( pEmr->xformSrc);        printf("\n");
+   printf("   crBkColorSrc:   ");     colorref_print( pEmr->crBkColorSrc); printf("\n");
+   printf("   iUsageSrc:      %u\n",  pEmr->iUsageSrc   );
+   printf("   offBmiSrc:      %u\n",  pEmr->offBmiSrc   );
+   printf("   cbBmiSrc:       %u\n",  pEmr->cbBmiSrc    );
+   if(pEmr->cbBmiSrc){
+      printf("      Src bitmap:  ");
+      bitmapinfo_print(contents + pEmr->offBmiSrc, blimit);
+      printf("\n");
+   }
+   printf("   offBitsSrc:     %u\n",  pEmr->offBitsSrc   );
+   printf("   cbBitsSrc:      %u\n",  pEmr->cbBitsSrc    );
+   printf("   Mask:           ");     pointl_print(pEmr->Mask);            printf("\n");
+   printf("   iUsageMask:     %u\n",  pEmr->iUsageMask   );
+   printf("   offBmiMask:     %u\n",  pEmr->offBmiMask   );
+   printf("   cbBmiMask:      %u\n",  pEmr->cbBmiMask    );
+   if(pEmr->cbBmiMask){
+      printf("      Mask bitmap: ");
+      bitmapinfo_print(contents + pEmr->offBmiMask, blimit);
+      printf("\n");
+   }
+   printf("   offBitsMask:    %u\n",  pEmr->offBitsMask   );
+   printf("   cbBitsMask:     %u\n",  pEmr->cbBitsMask    );
+}
+
+// U_EMRPLGBLT               79
+/**
+    \brief Print a pointer to a U_EMR_PLGBLT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPLGBLT_print(const char *contents){
+   PU_EMRPLGBLT pEmr = (PU_EMRPLGBLT) (contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRPLGBLT)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");     rectl_print( pEmr->rclBounds);       printf("\n");
+   printf("   aptlDst(UL):    ");     pointl_print(pEmr->aptlDst[0]);      printf("\n");
+   printf("   aptlDst(UR):    ");     pointl_print(pEmr->aptlDst[1]);      printf("\n");
+   printf("   aptlDst(LL):    ");     pointl_print(pEmr->aptlDst[2]);      printf("\n");
+   printf("   Src:            ");     pointl_print(pEmr->Src);             printf("\n");
+   printf("   cSrc:           ");     pointl_print(pEmr->cSrc);            printf("\n");
+   printf("   xformSrc:       ");     xform_print( pEmr->xformSrc);        printf("\n");
+   printf("   crBkColorSrc:   ");     colorref_print( pEmr->crBkColorSrc); printf("\n");
+   printf("   iUsageSrc:      %u\n", pEmr->iUsageSrc   );
+   printf("   offBmiSrc:      %u\n", pEmr->offBmiSrc   );
+   printf("   cbBmiSrc:       %u\n", pEmr->cbBmiSrc    );
+   if(pEmr->cbBmiSrc){
+      printf("      Src bitmap:  ");
+      bitmapinfo_print(contents + pEmr->offBmiSrc, blimit);
+      printf("\n");
+   }
+   printf("   offBitsSrc:     %u\n", pEmr->offBitsSrc   );
+   printf("   cbBitsSrc:      %u\n", pEmr->cbBitsSrc    );
+   printf("   Mask:           ");    pointl_print(pEmr->Mask);            printf("\n");
+   printf("   iUsageMsk:      %u\n", pEmr->iUsageMask   );
+   printf("   offBmiMask:     %u\n", pEmr->offBmiMask   );
+   printf("   cbBmiMask:      %u\n", pEmr->cbBmiMask    );
+   if(pEmr->cbBmiMask){
+      printf("      Mask bitmap: ");
+      bitmapinfo_print(contents + pEmr->offBmiMask, blimit);
+      printf("\n");
+   }
+   printf("   offBitsMask:    %u\n", pEmr->offBitsMask   );
+   printf("   cbBitsMask:     %u\n", pEmr->cbBitsMask    );
+}
+
+// U_EMRSETDIBITSTODEVICE    80
+/**
+    \brief Print a pointer to a U_EMRSETDIBITSTODEVICE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETDIBITSTODEVICE_print(const char *contents){
+   PU_EMRSETDIBITSTODEVICE pEmr = (PU_EMRSETDIBITSTODEVICE) (contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRSETDIBITSTODEVICE)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");     rectl_print( pEmr->rclBounds);       printf("\n");
+   printf("   Dest:           ");     pointl_print(pEmr->Dest);            printf("\n");
+   printf("   Src:            ");     pointl_print(pEmr->Src);             printf("\n");
+   printf("   cSrc:           ");     pointl_print(pEmr->cSrc);            printf("\n");
+   printf("   offBmiSrc:      %u\n", pEmr->offBmiSrc   );
+   printf("   cbBmiSrc:       %u\n", pEmr->cbBmiSrc    );
+   if(pEmr->cbBmiSrc){
+      printf("      Src bitmap:  ");
+      bitmapinfo_print(contents + pEmr->offBmiSrc, blimit);
+      printf("\n");
+   }
+   printf("   offBitsSrc:     %u\n", pEmr->offBitsSrc   );
+   printf("   cbBitsSrc:      %u\n", pEmr->cbBitsSrc    );
+   printf("   iUsageSrc:      %u\n", pEmr->iUsageSrc   );
+   printf("   iStartScan:     %u\n", pEmr->iStartScan    );
+   printf("   cScans :        %u\n", pEmr->cScans        );
+}
+
+// U_EMRSTRETCHDIBITS        81
+/**
+    \brief Print a pointer to a U_EMR_STRETCHDIBITS record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSTRETCHDIBITS_print(const char *contents){
+   PU_EMRSTRETCHDIBITS pEmr = (PU_EMRSTRETCHDIBITS) (contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRSTRETCHDIBITS)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");     rectl_print( pEmr->rclBounds);       printf("\n");
+   printf("   Dest:           ");     pointl_print(pEmr->Dest);            printf("\n");
+   printf("   Src:            ");     pointl_print(pEmr->Src);             printf("\n");
+   printf("   cSrc:           ");     pointl_print(pEmr->cSrc);            printf("\n");
+   printf("   offBmiSrc:      %u\n", pEmr->offBmiSrc   );
+   printf("   cbBmiSrc:       %u\n", pEmr->cbBmiSrc    );
+   if(pEmr->cbBmiSrc){
+      printf("      Src bitmap:  ");
+      bitmapinfo_print(contents + pEmr->offBmiSrc, blimit);
+      printf("\n");
+   }
+   printf("   offBitsSrc:     %u\n", pEmr->offBitsSrc   );
+   printf("   cbBitsSrc:      %u\n", pEmr->cbBitsSrc    );
+   printf("   iUsageSrc:      %u\n", pEmr->iUsageSrc   );
+   printf("   dwRop :         0x%8.8X\n", pEmr->dwRop   );
+   printf("   cDest:          ");     pointl_print(pEmr->cDest);           printf("\n");
+}
+
+// U_EMREXTCREATEFONTINDIRECTW_print    82
+/**
+    \brief Print a pointer to a U_EMR_EXTCREATEFONTINDIRECTW record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMREXTCREATEFONTINDIRECTW_print(const char *contents){
+   PU_EMREXTCREATEFONTINDIRECTW pEmr = (PU_EMREXTCREATEFONTINDIRECTW) (contents);
+   if(pEmr->emr.nSize < U_SIZE_EMREXTCREATEFONTINDIRECTW_LOGFONT){ // smallest variant
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   ihFont:         %u\n",pEmr->ihFont );
+   printf("   Font:           ");
+   if(pEmr->emr.nSize == U_SIZE_EMREXTCREATEFONTINDIRECTW_LOGFONT_PANOSE){ // holds logfont_panose
+      IF_MEM_UNSAFE_PRINT_AND_RETURN(&(pEmr->elfw), sizeof(U_PANOSE), blimit);
+      logfont_panose_print(pEmr->elfw);
+   }
+   else { // holds logfont or logfontExDv.  The latter isn't supported but it starts with logfont, so use that
+      IF_MEM_UNSAFE_PRINT_AND_RETURN(&(pEmr->elfw), sizeof(U_LOGFONT), blimit);
+      logfont_print( *(PU_LOGFONT) &(pEmr->elfw));
+   }
+   printf("\n");
+}
+
+// U_EMREXTTEXTOUTA          83
+/**
+    \brief Print a pointer to a U_EMR_EXTTEXTOUTA record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMREXTTEXTOUTA_print(const char *contents){
+   core8_print("U_EMREXTTEXTOUTA", contents, 0);
+}
+
+// U_EMREXTTEXTOUTW          84
+/**
+    \brief Print a pointer to a U_EMR_EXTTEXTOUTW record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMREXTTEXTOUTW_print(const char *contents){
+   core8_print("U_EMREXTTEXTOUTW", contents, 1);
+}
+
+// U_EMRPOLYBEZIER16         85
+/**
+    \brief Print a pointer to a U_EMR_POLYBEZIER16 record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPOLYBEZIER16_print(const char *contents){
+   core6_print("U_EMRPOLYBEZIER16", contents);
+}
+
+// U_EMRPOLYGON16            86
+/**
+    \brief Print a pointer to a U_EMR_POLYGON16 record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPOLYGON16_print(const char *contents){
+   core6_print("U_EMRPOLYGON16", contents);
+}
+
+// U_EMRPOLYLINE16           87
+/**
+    \brief Print a pointer to a U_EMR_POLYLINE16 record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPOLYLINE16_print(const char *contents){
+   core6_print("U_EMRPOLYLINE16", contents);
+}
+
+// U_EMRPOLYBEZIERTO16       88
+/**
+    \brief Print a pointer to a U_EMR_POLYBEZIERTO16 record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPOLYBEZIERTO16_print(const char *contents){
+   core6_print("U_EMRPOLYBEZIERTO16", contents);
+}
+
+// U_EMRPOLYLINETO16         89
+/**
+    \brief Print a pointer to a U_EMR_POLYLINETO16 record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPOLYLINETO16_print(const char *contents){
+   core6_print("U_EMRPOLYLINETO16", contents);
+}
+
+// U_EMRPOLYPOLYLINE16       90
+/**
+    \brief Print a pointer to a U_EMR_POLYPOLYLINE16 record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPOLYPOLYLINE16_print(const char *contents){
+   core10_print("U_EMRPOLYPOLYLINE16", contents);
+}
+
+// U_EMRPOLYPOLYGON16        91
+/**
+    \brief Print a pointer to a U_EMR_POLYPOLYGON16 record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPOLYPOLYGON16_print(const char *contents){
+   core10_print("U_EMRPOLYPOLYGON16", contents);
+}
+
+
+// U_EMRPOLYDRAW16           92
+/**
+    \brief Print a pointer to a U_EMR_POLYDRAW16 record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPOLYDRAW16_print(const char *contents){
+   unsigned int i;
+   PU_EMRPOLYDRAW16 pEmr = (PU_EMRPOLYDRAW16)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRPOLYDRAW16)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");          rectl_print( pEmr->rclBounds);   printf("\n");
+   printf("   cpts:           %d\n",pEmr->cpts        );
+   printf("   Points:         ");
+   IF_MEM_UNSAFE_PRINT_AND_RETURN(pEmr->apts, pEmr->cpts*sizeof(U_POINT16), blimit);
+   for(i=0;i<pEmr->cpts; i++){
+      printf(" [%d]:",i);
+      point16_print(pEmr->apts[i]);
+   }
+   printf("\n");
+   printf("   Types:          ");
+   const char *abTypes = (const char *) pEmr->apts + pEmr->cpts*sizeof(U_POINT16);
+   IF_MEM_UNSAFE_PRINT_AND_RETURN(abTypes, pEmr->cpts, blimit);
+   for(i=0;i<pEmr->cpts; i++){
+      printf(" [%d]:%u ",i,((uint8_t *)abTypes)[i]);
+   }
+   printf("\n");
+}
+
+// U_EMRCREATEMONOBRUSH      93
+/**
+    \brief Print a pointer to a U_EMR_CREATEMONOBRUSH record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRCREATEMONOBRUSH_print(const char *contents){
+   core12_print("U_EMRCREATEMONOBRUSH", contents);
+}
+
+// U_EMRCREATEDIBPATTERNBRUSHPT_print   94
+/**
+    \brief Print a pointer to a U_EMR_CREATEDIBPATTERNBRUSHPT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRCREATEDIBPATTERNBRUSHPT_print(const char *contents){
+   core12_print("U_EMRCREATEDIBPATTERNBRUSHPT", contents);
+}
+
+
+// U_EMREXTCREATEPEN         95
+/**
+    \brief Print a pointer to a U_EMR_EXTCREATEPEN record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMREXTCREATEPEN_print(const char *contents){
+   PU_EMREXTCREATEPEN pEmr = (PU_EMREXTCREATEPEN)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMREXTCREATEPEN)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   ihPen:          %u\n", pEmr->ihPen );
+   printf("   offBmi:         %u\n", pEmr->offBmi   );
+   printf("   cbBmi:          %u\n", pEmr->cbBmi    );
+   if(pEmr->cbBmi){
+      printf("      bitmap:      ");
+      bitmapinfo_print(contents + pEmr->offBmi, blimit);
+      printf("\n");
+   }
+   printf("   offBits:        %u\n", pEmr->offBits   );
+   printf("   cbBits:         %u\n", pEmr->cbBits    );
+   printf("   elp:            ");     extlogpen_print((PU_EXTLOGPEN) &(pEmr->elp));  printf("\n");
+} 
+
+// U_EMRPOLYTEXTOUTA         96 NOT IMPLEMENTED, denigrated after Windows NT
+#define U_EMRPOLYTEXTOUTA_print(A) U_EMRNOTIMPLEMENTED_print("U_EMRPOLYTEXTOUTA",A) //!< Not implemented.
+// U_EMRPOLYTEXTOUTW         97 NOT IMPLEMENTED, denigrated after Windows NT
+#define U_EMRPOLYTEXTOUTW_print(A) U_EMRNOTIMPLEMENTED_print("U_EMRPOLYTEXTOUTW",A) //!< Not implemented.
+
+// U_EMRSETICMMODE           98
+/**
+    \brief Print a pointer to a U_EMR_SETICMMODE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETICMMODE_print(const char *contents){
+   core3_print("U_EMRSETICMMODE", "iMode:", contents);
+}
+
+// U_EMRCREATECOLORSPACE     99
+/**
+    \brief Print a pointer to a U_EMR_CREATECOLORSPACE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRCREATECOLORSPACE_print(const char *contents){
+   PU_EMRCREATECOLORSPACE pEmr = (PU_EMRCREATECOLORSPACE)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRCREATECOLORSPACE)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   printf("   ihCS:           %u\n", pEmr->ihCS    );
+   printf("   ColorSpace:     "); logcolorspacea_print(pEmr->lcs);  printf("\n");
+}
+
+// U_EMRSETCOLORSPACE       100
+/**
+    \brief Print a pointer to a U_EMR_SETCOLORSPACE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETCOLORSPACE_print(const char *contents){
+   core3_print("U_EMRSETCOLORSPACE", "ihCS:", contents);
+}
+
+// U_EMRDELETECOLORSPACE    101
+/**
+    \brief Print a pointer to a U_EMR_DELETECOLORSPACE record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRDELETECOLORSPACE_print(const char *contents){
+   core3_print("U_EMRDELETECOLORSPACE", "ihCS:", contents);
+}
+
+// U_EMRGLSRECORD           102  Not implemented
+#define U_EMRGLSRECORD_print(A) U_EMRNOTIMPLEMENTED_print("U_EMRGLSRECORD",A) //!< Not implemented.
+// U_EMRGLSBOUNDEDRECORD    103  Not implemented
+#define U_EMRGLSBOUNDEDRECORD_print(A) U_EMRNOTIMPLEMENTED_print("U_EMRGLSBOUNDEDRECORD",A) //!< Not implemented.
+
+// U_EMRPIXELFORMAT         104
+/**
+    \brief Print a pointer to a U_EMR_PIXELFORMAT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRPIXELFORMAT_print(const char *contents){
+   PU_EMRPIXELFORMAT pEmr = (PU_EMRPIXELFORMAT)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRPIXELFORMAT)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   IF_MEM_UNSAFE_PRINT_AND_RETURN(&(pEmr->pfd), sizeof(U_PIXELFORMATDESCRIPTOR), blimit);
+   printf("   Pfd:            ");  pixelformatdescriptor_print(pEmr->pfd);  printf("\n");
+}
+
+// U_EMRDRAWESCAPE          105  Not implemented
+#define U_EMRDRAWESCAPE_print(A) U_EMRNOTIMPLEMENTED_print("U_EMRDRAWESCAPE",A) //!< Not implemented.
+// U_EMREXTESCAPE           106  Not implemented
+#define U_EMREXTESCAPE_print(A) U_EMRNOTIMPLEMENTED_print("U_EMREXTESCAPE",A) //!< Not implemented.
+// U_EMRUNDEF107            107  Not implemented
+#define U_EMRUNDEF107_print(A) U_EMRNOTIMPLEMENTED_print("U_EMRUNDEF107",A) //!< Not implemented.
+
+// U_EMRSMALLTEXTOUT        108
+/**
+    \brief Print a pointer to a U_EMR_SMALLTEXTOUT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSMALLTEXTOUT_print(const char *contents){
+   int roff;
+   char *string;
+   PU_EMRSMALLTEXTOUT pEmr = (PU_EMRSMALLTEXTOUT)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRSMALLTEXTOUT)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   Dest:           ");         pointl_print(pEmr->Dest);            printf("\n");
+   printf("   cChars:         %u\n",      pEmr->cChars          );
+   printf("   fuOptions:      0x%8.8X\n", pEmr->fuOptions       );
+   printf("   iGraphicsMode:  0x%8.8X\n", pEmr->iGraphicsMode   );
+   printf("   exScale:        %f\n",      pEmr->exScale         );
+   printf("   eyScale:        %f\n",      pEmr->eyScale         );
+   roff = sizeof(U_EMRSMALLTEXTOUT);  //offset to the start of the variable fields
+   if(!(pEmr->fuOptions & U_ETO_NO_RECT)){
+      IF_MEM_UNSAFE_PRINT_AND_RETURN(contents, roff, blimit);
+      printf("   rclBounds:      ");      rectl_print( *(PU_RECTL) (contents + roff));       printf("\n");
+      roff += sizeof(U_RECTL);
+   }
+   if(pEmr->fuOptions & U_ETO_SMALL_CHARS){
+      IF_MEM_UNSAFE_PRINT_AND_RETURN(contents, roff + pEmr->cChars*sizeof(char), blimit);
+      printf("   Text8:          <%.*s>\n",pEmr->cChars,contents+roff);  /* May not be null terminated */
+   }
+   else {
+      string = U_Utf16leToUtf8((uint16_t *)(contents+roff), pEmr->cChars, NULL);
+      IF_MEM_UNSAFE_PRINT_AND_RETURN(contents, roff + pEmr->cChars*2*sizeof(char), blimit);
+      printf("   Text16:         <%s>\n",contents+roff);
+      free(string);
+  }
+}
+
+// U_EMRFORCEUFIMAPPING     109  Not implemented
+#define U_EMRFORCEUFIMAPPING_print(A)     U_EMRNOTIMPLEMENTED_print("U_EMRFORCEUFIMAPPING",A) //!< Not implemented.
+// U_EMRNAMEDESCAPE         110  Not implemented
+#define U_EMRNAMEDESCAPE_print(A)         U_EMRNOTIMPLEMENTED_print("U_EMRNAMEDESCAPE",A) //!< Not implemented.
+// U_EMRCOLORCORRECTPALETTE 111  Not implemented
+#define U_EMRCOLORCORRECTPALETTE_print(A) U_EMRNOTIMPLEMENTED_print("U_EMRCOLORCORRECTPALETTE",A) //!< Not implemented.
+// U_EMRSETICMPROFILEA      112  Not implemented
+#define U_EMRSETICMPROFILEA_print(A)      U_EMRNOTIMPLEMENTED_print("U_EMRSETICMPROFILEA",A) //!< Not implemented.
+// U_EMRSETICMPROFILEW      113  Not implemented
+#define U_EMRSETICMPROFILEW_print(A)      U_EMRNOTIMPLEMENTED_print("U_EMRSETICMPROFILEW",A) //!< Not implemented.
+
+// U_EMRALPHABLEND          114
+/**
+    \brief Print a pointer to a U_EMR_ALPHABLEND record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRALPHABLEND_print(const char *contents){
+   core13_print("U_EMRALPHABLEND", contents);
+}
+
+// U_EMRSETLAYOUT           115
+/**
+    \brief Print a pointer to a U_EMR_SETLAYOUT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRSETLAYOUT_print(const char *contents){
+   core3_print("U_EMRSETLAYOUT", "iMode:", contents);
+}
+
+// U_EMRTRANSPARENTBLT      116
+/**
+    \brief Print a pointer to a U_EMR_TRANSPARENTBLT record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRTRANSPARENTBLT_print(const char *contents){
+   core13_print("U_EMRTRANSPARENTBLT", contents);
+}
+
+// U_EMRUNDEF117            117  Not implemented
+#define U_EMRUNDEF117_print(A)    U_EMRNOTIMPLEMENTED_print("U_EMRUNDEF117",A) //!< Not implemented.
+// U_EMRGRADIENTFILL        118
+/**
+    \brief Print a pointer to a U_EMR_GRADIENTFILL record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRGRADIENTFILL_print(const char *contents){
+   unsigned int i;
+   PU_EMRGRADIENTFILL pEmr = (PU_EMRGRADIENTFILL)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRGRADIENTFILL)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   rclBounds:      ");      rectl_print( pEmr->rclBounds);   printf("\n");
+   printf("   nTriVert:       %u\n",   pEmr->nTriVert   );
+   printf("   nGradObj:       %u\n",   pEmr->nGradObj   );
+   printf("   ulMode:         %u\n",   pEmr->ulMode     );
+   contents += sizeof(U_EMRGRADIENTFILL);
+   if(pEmr->nTriVert){
+      IF_MEM_UNSAFE_PRINT_AND_RETURN(contents, pEmr->nTriVert*sizeof(U_TRIVERTEX), blimit);
+      printf("   TriVert:        ");
+      for(i=0; i<pEmr->nTriVert; i++, contents+=sizeof(U_TRIVERTEX)){
+         trivertex_print(*(PU_TRIVERTEX)(contents));
+      }
+      printf("\n");
+   }
+   if(pEmr->nGradObj){
+      printf("   GradObj:        ");
+      if(     pEmr->ulMode == U_GRADIENT_FILL_TRIANGLE){
+         IF_MEM_UNSAFE_PRINT_AND_RETURN(contents, pEmr->nGradObj*sizeof(U_GRADIENT3), blimit);
+         for(i=0; i<pEmr->nGradObj; i++, contents+=sizeof(U_GRADIENT3)){
+            gradient3_print(*(PU_GRADIENT3)(contents));
+         }
+      }
+      else if(pEmr->ulMode == U_GRADIENT_FILL_RECT_H || 
+              pEmr->ulMode == U_GRADIENT_FILL_RECT_V){
+         IF_MEM_UNSAFE_PRINT_AND_RETURN(contents, pEmr->nGradObj*sizeof(U_GRADIENT4), blimit);
+         for(i=0; i<pEmr->nGradObj; i++, contents+=sizeof(U_GRADIENT4)){
+            gradient4_print(*(PU_GRADIENT4)(contents));
+         }
+      }
+      else { printf("invalid ulMode value!"); }
+      printf("\n");
+   }
+}
+
+// U_EMRSETLINKEDUFIS       119  Not implemented
+#define U_EMRSETLINKEDUFIS_print(A)        U_EMRNOTIMPLEMENTED_print("U_EMR_SETLINKEDUFIS",A) //!< Not implemented.
+// U_EMRSETTEXTJUSTIFICATION120  Not implemented (denigrated)
+#define U_EMRSETTEXTJUSTIFICATION_print(A) U_EMRNOTIMPLEMENTED_print("U_EMR_SETTEXTJUSTIFICATION",A) //!< Not implemented.
+// U_EMRCOLORMATCHTOTARGETW 121  Not implemented  
+#define U_EMRCOLORMATCHTOTARGETW_print(A)  U_EMRNOTIMPLEMENTED_print("U_EMR_COLORMATCHTOTARGETW",A) //!< Not implemented.
+
+// U_EMRCREATECOLORSPACEW   122
+/**
+    \brief Print a pointer to a U_EMR_CREATECOLORSPACEW record.
+    \param contents   pointer to a buffer holding all EMR records
+*/
+void U_EMRCREATECOLORSPACEW_print(const char *contents){
+   unsigned int i;
+   PU_EMRCREATECOLORSPACEW pEmr = (PU_EMRCREATECOLORSPACEW)(contents);
+   if(pEmr->emr.nSize < sizeof(U_EMRCREATECOLORSPACEW)){
+      printf("   record corruption HERE\n");
+      return;
+   }
+   const char *blimit = contents + pEmr->emr.nSize;
+   printf("   ihCS:           %u\n", pEmr->ihCS     );
+   printf("   ColorSpace:     "); logcolorspacew_print(pEmr->lcs);  printf("\n");
+   printf("   dwFlags:        0x%8.8X\n", pEmr->dwFlags  );
+   printf("   cbData:         %u\n", pEmr->cbData   );
+   printf("   Data(hexvalues):");
+   if(pEmr->dwFlags & 1){
+     IF_MEM_UNSAFE_PRINT_AND_RETURN(contents, pEmr->cbData, blimit);
+     for(i=0; i<pEmr->cbData; i++){
+        printf("[%d]:%2.2X ",i,pEmr->Data[i]);
+     }
+   }
+   printf("\n");
+}
+
+/**
+    \brief Print any record in an emf
+    \returns record length for a normal record, 0 for EMREOF, -1 for a bad record
+    \param contents   pointer to a buffer holding all EMR records
+    \param blimit     pointer to the byte after the last byte in the buffer holding all EMR records
+    \param recnum     number of this record in contents
+    \param off        offset to this record in contents
+*/
+int U_emf_onerec_print(const char *contents, const char *blimit, int recnum, size_t off){
+    PU_ENHMETARECORD  lpEMFR  = (PU_ENHMETARECORD)(contents + off);
+    uint32_t nSize;
+    uint32_t iType;
+    const char *record = contents + off;
+
+    if(record < contents)return(-1); // offset wrapped
+
+    /* Check that COMMON data in record can be touched without an access violation.  If it cannot be
+        this is either a corrupt EMF or one engineered to cause a buffer overflow.  Pointer math
+        could wrap so check both sides of the range.
+    */
+    if(!U_emf_record_sizeok(record, blimit, &nSize, &iType, 1))return(-1); 
+    
+    uint32_t crc;   
+#if U_BYTE_SWAP
+    //This is a Big Endian machine, EMF crc values must be calculated on Little Endian form
+    char *swapbuf=malloc(nSize);
+    if(!swapbuf)return(-1);
+    memcpy(swapbuf,record,nSize);
+    U_emf_endian(swapbuf,nSize,1);  // BE to LE
+    crc=lu_crc32(swapbuf,nSize);
+    free(swapbuf);
+#else 
+    crc=lu_crc32(record,nSize);
+#endif
+    printf("%-30srecord:%5d type:%-4d offset:%8d rsize:%8d crc32:%8.8X\n",
+       U_emr_names(iType),recnum,iType,(int) off,nSize,crc);
+    
+    fflush(stdout);
+
+    /* print the record header before checking further.
+       Note if this is a corrupt record, but continue anyway.
+       The _print routines will stop at the actual problem and print another corrupt message.
+    */
+    if(!U_emf_record_safe(record)){printf("WARNING: Corrupt record.  Emitting fields above the problem.\n");}
+    
+    switch (lpEMFR->iType)
+    {
+        case U_EMR_HEADER:                  U_EMRHEADER_print(record);                  break;
+        case U_EMR_POLYBEZIER:              U_EMRPOLYBEZIER_print(record);              break;
+        case U_EMR_POLYGON:                 U_EMRPOLYGON_print(record);                 break;
+        case U_EMR_POLYLINE:                U_EMRPOLYLINE_print(record);                break;
+        case U_EMR_POLYBEZIERTO:            U_EMRPOLYBEZIERTO_print(record);            break;
+        case U_EMR_POLYLINETO:              U_EMRPOLYLINETO_print(record);              break;
+        case U_EMR_POLYPOLYLINE:            U_EMRPOLYPOLYLINE_print(record);            break;
+        case U_EMR_POLYPOLYGON:             U_EMRPOLYPOLYGON_print(record);             break;
+        case U_EMR_SETWINDOWEXTEX:          U_EMRSETWINDOWEXTEX_print(record);          break;
+        case U_EMR_SETWINDOWORGEX:          U_EMRSETWINDOWORGEX_print(record);          break;
+        case U_EMR_SETVIEWPORTEXTEX:        U_EMRSETVIEWPORTEXTEX_print(record);        break;
+        case U_EMR_SETVIEWPORTORGEX:        U_EMRSETVIEWPORTORGEX_print(record);        break;
+        case U_EMR_SETBRUSHORGEX:           U_EMRSETBRUSHORGEX_print(record);           break;
+        case U_EMR_EOF:                     U_EMREOF_print(record);         nSize=0;    break;
+        case U_EMR_SETPIXELV:               U_EMRSETPIXELV_print(record);               break;
+        case U_EMR_SETMAPPERFLAGS:          U_EMRSETMAPPERFLAGS_print(record);          break;
+        case U_EMR_SETMAPMODE:              U_EMRSETMAPMODE_print(record);              break;
+        case U_EMR_SETBKMODE:               U_EMRSETBKMODE_print(record);               break;
+        case U_EMR_SETPOLYFILLMODE:         U_EMRSETPOLYFILLMODE_print(record);         break;
+        case U_EMR_SETROP2:                 U_EMRSETROP2_print(record);                 break;
+        case U_EMR_SETSTRETCHBLTMODE:       U_EMRSETSTRETCHBLTMODE_print(record);       break;
+        case U_EMR_SETTEXTALIGN:            U_EMRSETTEXTALIGN_print(record);            break;
+        case U_EMR_SETCOLORADJUSTMENT:      U_EMRSETCOLORADJUSTMENT_print(record);      break;
+        case U_EMR_SETTEXTCOLOR:            U_EMRSETTEXTCOLOR_print(record);            break;
+        case U_EMR_SETBKCOLOR:              U_EMRSETBKCOLOR_print(record);              break;
+        case U_EMR_OFFSETCLIPRGN:           U_EMROFFSETCLIPRGN_print(record);           break;
+        case U_EMR_MOVETOEX:                U_EMRMOVETOEX_print(record);                break;
+        case U_EMR_SETMETARGN:              U_EMRSETMETARGN_print(record);              break;
+        case U_EMR_EXCLUDECLIPRECT:         U_EMREXCLUDECLIPRECT_print(record);         break;
+        case U_EMR_INTERSECTCLIPRECT:       U_EMRINTERSECTCLIPRECT_print(record);       break;
+        case U_EMR_SCALEVIEWPORTEXTEX:      U_EMRSCALEVIEWPORTEXTEX_print(record);      break;
+        case U_EMR_SCALEWINDOWEXTEX:        U_EMRSCALEWINDOWEXTEX_print(record);        break;
+        case U_EMR_SAVEDC:                  U_EMRSAVEDC_print(record);                  break;
+        case U_EMR_RESTOREDC:               U_EMRRESTOREDC_print(record);               break;
+        case U_EMR_SETWORLDTRANSFORM:       U_EMRSETWORLDTRANSFORM_print(record);       break;
+        case U_EMR_MODIFYWORLDTRANSFORM:    U_EMRMODIFYWORLDTRANSFORM_print(record);    break;
+        case U_EMR_SELECTOBJECT:            U_EMRSELECTOBJECT_print(record);            break;
+        case U_EMR_CREATEPEN:               U_EMRCREATEPEN_print(record);               break;
+        case U_EMR_CREATEBRUSHINDIRECT:     U_EMRCREATEBRUSHINDIRECT_print(record);     break;
+        case U_EMR_DELETEOBJECT:            U_EMRDELETEOBJECT_print(record);            break;
+        case U_EMR_ANGLEARC:                U_EMRANGLEARC_print(record);                break;
+        case U_EMR_ELLIPSE:                 U_EMRELLIPSE_print(record);                 break;
+        case U_EMR_RECTANGLE:               U_EMRRECTANGLE_print(record);               break;
+        case U_EMR_ROUNDRECT:               U_EMRROUNDRECT_print(record);               break;
+        case U_EMR_ARC:                     U_EMRARC_print(record);                     break;
+        case U_EMR_CHORD:                   U_EMRCHORD_print(record);                   break;
+        case U_EMR_PIE:                     U_EMRPIE_print(record);                     break;
+        case U_EMR_SELECTPALETTE:           U_EMRSELECTPALETTE_print(record);           break;
+        case U_EMR_CREATEPALETTE:           U_EMRCREATEPALETTE_print(record);           break;
+        case U_EMR_SETPALETTEENTRIES:       U_EMRSETPALETTEENTRIES_print(record);       break;
+        case U_EMR_RESIZEPALETTE:           U_EMRRESIZEPALETTE_print(record);           break;
+        case U_EMR_REALIZEPALETTE:          U_EMRREALIZEPALETTE_print(record);          break;
+        case U_EMR_EXTFLOODFILL:            U_EMREXTFLOODFILL_print(record);            break;
+        case U_EMR_LINETO:                  U_EMRLINETO_print(record);                  break;
+        case U_EMR_ARCTO:                   U_EMRARCTO_print(record);                   break;
+        case U_EMR_POLYDRAW:                U_EMRPOLYDRAW_print(record);                break;
+        case U_EMR_SETARCDIRECTION:         U_EMRSETARCDIRECTION_print(record);         break;
+        case U_EMR_SETMITERLIMIT:           U_EMRSETMITERLIMIT_print(record);           break;
+        case U_EMR_BEGINPATH:               U_EMRBEGINPATH_print(record);               break;
+        case U_EMR_ENDPATH:                 U_EMRENDPATH_print(record);                 break;
+        case U_EMR_CLOSEFIGURE:             U_EMRCLOSEFIGURE_print(record);             break;
+        case U_EMR_FILLPATH:                U_EMRFILLPATH_print(record);                break;
+        case U_EMR_STROKEANDFILLPATH:       U_EMRSTROKEANDFILLPATH_print(record);       break;
+        case U_EMR_STROKEPATH:              U_EMRSTROKEPATH_print(record);              break;
+        case U_EMR_FLATTENPATH:             U_EMRFLATTENPATH_print(record);             break;
+        case U_EMR_WIDENPATH:               U_EMRWIDENPATH_print(record);               break;
+        case U_EMR_SELECTCLIPPATH:          U_EMRSELECTCLIPPATH_print(record);          break;
+        case U_EMR_ABORTPATH:               U_EMRABORTPATH_print(record);               break;
+        case U_EMR_UNDEF69:                 U_EMRUNDEF69_print(record);                 break;
+        case U_EMR_COMMENT:                 U_EMRCOMMENT_print(record, off);            break;
+        case U_EMR_FILLRGN:                 U_EMRFILLRGN_print(record);                 break;
+        case U_EMR_FRAMERGN:                U_EMRFRAMERGN_print(record);                break;
+        case U_EMR_INVERTRGN:               U_EMRINVERTRGN_print(record);               break;
+        case U_EMR_PAINTRGN:                U_EMRPAINTRGN_print(record);                break;
+        case U_EMR_EXTSELECTCLIPRGN:        U_EMREXTSELECTCLIPRGN_print(record);        break;
+        case U_EMR_BITBLT:                  U_EMRBITBLT_print(record);                  break;
+        case U_EMR_STRETCHBLT:              U_EMRSTRETCHBLT_print(record);              break;
+        case U_EMR_MASKBLT:                 U_EMRMASKBLT_print(record);                 break;
+        case U_EMR_PLGBLT:                  U_EMRPLGBLT_print(record);                  break;
+        case U_EMR_SETDIBITSTODEVICE:       U_EMRSETDIBITSTODEVICE_print(record);       break;
+        case U_EMR_STRETCHDIBITS:           U_EMRSTRETCHDIBITS_print(record);           break;
+        case U_EMR_EXTCREATEFONTINDIRECTW:  U_EMREXTCREATEFONTINDIRECTW_print(record);  break;
+        case U_EMR_EXTTEXTOUTA:             U_EMREXTTEXTOUTA_print(record);             break;
+        case U_EMR_EXTTEXTOUTW:             U_EMREXTTEXTOUTW_print(record);             break;
+        case U_EMR_POLYBEZIER16:            U_EMRPOLYBEZIER16_print(record);            break;
+        case U_EMR_POLYGON16:               U_EMRPOLYGON16_print(record);               break;
+        case U_EMR_POLYLINE16:              U_EMRPOLYLINE16_print(record);              break;
+        case U_EMR_POLYBEZIERTO16:          U_EMRPOLYBEZIERTO16_print(record);          break;
+        case U_EMR_POLYLINETO16:            U_EMRPOLYLINETO16_print(record);            break;
+        case U_EMR_POLYPOLYLINE16:          U_EMRPOLYPOLYLINE16_print(record);          break;
+        case U_EMR_POLYPOLYGON16:           U_EMRPOLYPOLYGON16_print(record);           break;
+        case U_EMR_POLYDRAW16:              U_EMRPOLYDRAW16_print(record);              break;
+        case U_EMR_CREATEMONOBRUSH:         U_EMRCREATEMONOBRUSH_print(record);         break;
+        case U_EMR_CREATEDIBPATTERNBRUSHPT: U_EMRCREATEDIBPATTERNBRUSHPT_print(record); break;
+        case U_EMR_EXTCREATEPEN:            U_EMREXTCREATEPEN_print(record);            break;
+        case U_EMR_POLYTEXTOUTA:            U_EMRPOLYTEXTOUTA_print(record);            break;
+        case U_EMR_POLYTEXTOUTW:            U_EMRPOLYTEXTOUTW_print(record);            break;
+        case U_EMR_SETICMMODE:              U_EMRSETICMMODE_print(record);              break;
+        case U_EMR_CREATECOLORSPACE:        U_EMRCREATECOLORSPACE_print(record);        break;
+        case U_EMR_SETCOLORSPACE:           U_EMRSETCOLORSPACE_print(record);           break;
+        case U_EMR_DELETECOLORSPACE:        U_EMRDELETECOLORSPACE_print(record);        break;
+        case U_EMR_GLSRECORD:               U_EMRGLSRECORD_print(record);               break;
+        case U_EMR_GLSBOUNDEDRECORD:        U_EMRGLSBOUNDEDRECORD_print(record);        break;
+        case U_EMR_PIXELFORMAT:             U_EMRPIXELFORMAT_print(record);             break;
+        case U_EMR_DRAWESCAPE:              U_EMRDRAWESCAPE_print(record);              break;
+        case U_EMR_EXTESCAPE:               U_EMREXTESCAPE_print(record);               break;
+        case U_EMR_UNDEF107:                U_EMRUNDEF107_print(record);                break;
+        case U_EMR_SMALLTEXTOUT:            U_EMRSMALLTEXTOUT_print(record);            break;
+        case U_EMR_FORCEUFIMAPPING:         U_EMRFORCEUFIMAPPING_print(record);         break;
+        case U_EMR_NAMEDESCAPE:             U_EMRNAMEDESCAPE_print(record);             break;
+        case U_EMR_COLORCORRECTPALETTE:     U_EMRCOLORCORRECTPALETTE_print(record);     break;
+        case U_EMR_SETICMPROFILEA:          U_EMRSETICMPROFILEA_print(record);          break;
+        case U_EMR_SETICMPROFILEW:          U_EMRSETICMPROFILEW_print(record);          break;
+        case U_EMR_ALPHABLEND:              U_EMRALPHABLEND_print(record);              break;
+        case U_EMR_SETLAYOUT:               U_EMRSETLAYOUT_print(record);               break;
+        case U_EMR_TRANSPARENTBLT:          U_EMRTRANSPARENTBLT_print(record);          break;
+        case U_EMR_UNDEF117:                U_EMRUNDEF117_print(record);                break;
+        case U_EMR_GRADIENTFILL:            U_EMRGRADIENTFILL_print(record);            break;
+        case U_EMR_SETLINKEDUFIS:           U_EMRSETLINKEDUFIS_print(record);           break;
+        case U_EMR_SETTEXTJUSTIFICATION:    U_EMRSETTEXTJUSTIFICATION_print(record);    break;
+        case U_EMR_COLORMATCHTOTARGETW:     U_EMRCOLORMATCHTOTARGETW_print(record);     break;
+        case U_EMR_CREATECOLORSPACEW:       U_EMRCREATECOLORSPACEW_print(record);       break;
+        default:                            U_EMRNOTIMPLEMENTED_print("?",record);      break;
+    }  //end of switch
+    return(nSize);
+}
+
+
+#ifdef __cplusplus
+}
+#endif