Adding upstream version 1.2.2.upstream/1.2.2upstream

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

1 files changed, 1204 insertions, 0 deletions

diff --git a/src/3rdparty/libuemf/uemf_safe.c b/src/3rdparty/libuemf/uemf_safe.c
new file mode 100644
index 0000000..a3e0502
--- /dev/null
+++ b/src/3rdparty/libuemf/uemf_safe.c
@@ -0,0 +1,1204 @@
+/**
+  @file uemf_safe.c
+  
+  @brief Functions for checking EMF records for memory issues.
+   
+  EMF records come in a variety of sizes, and some types have variable sizes.
+  These functions check the record types and report if there are any issues
+    that could cause a memory access problem.  All counts and offsets are examined
+    and the data structure checked so that no referenced byte is outside of the
+    declared size of the record.
+
+  Many variables are initialized to zero even though they will always be set because
+  some versions of gcc give spurious "may be used uninitialized" warnings otherwise.
+*/
+
+/*
+File:      uemf_safe.c
+Version:   0.0.5
+Date:      26-JAN-2016
+Author:    David Mathog, Biology Division, Caltech
+email:     mathog@caltech.edu
+Copyright: 2016 David Mathog and California Institute of Technology (Caltech)
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stddef.h> /* for offsetof() macro */
+#include "uemf.h"
+#include "uemf_endian.h" // for u_emf_record_sizeok
+
+// hide almost everuything in here from Doxygen
+//! \cond
+
+/**
+    \brief Test a U_EXTLOGPEN object.
+    \param elp    PU_EXTLOGPEN object
+    \param blimit one byte past the end of the record
+*/
+int extlogpen_safe(
+      PU_EXTLOGPEN elp,
+      const char *blimit
+   ){
+   int count=elp->elpNumEntries;
+   if(IS_MEM_UNSAFE(&(elp->elpStyleEntry), count*4, blimit))return(0);
+   return(1);
+}
+
+/**
+    \brief Test a U_EMRTEXT record
+    \param pemt      Pointer to a U_EMRTEXT record 
+    \param record    Pointer to the start of the record which contains this U_EMRTEXT
+    \param blimit    one byte past the end of the record.
+*/
+int emrtext_safe(
+      PU_EMRTEXT  pemt,
+      const char *record,
+      const char *blimit
+   ){
+   int        off;
+   uint32_t   count    = pemt->nChars;
+   uint32_t   fOptions = pemt->fOptions;
+   uint32_t   offDx    = 0;
+   off = sizeof(U_EMRTEXT);
+   if(!(fOptions & U_ETO_NO_RECT)){
+       if(IS_MEM_UNSAFE(pemt, sizeof(U_RECTL), blimit))return(0);
+       off+=sizeof(U_RECTL);
+   }
+   offDx = *(uint32_t *)((char *)pemt +off);
+   if(IS_MEM_UNSAFE(pemt, off + 4, blimit))return(0);
+   if(IS_MEM_UNSAFE(record, offDx + count*4, blimit))return(0);
+   return(1);
+}
+
+/**
+    \return 1 on success, 0 on failure
+    \brief Test a U_RGNDATA object.
+    \param rd  pointer to a U_RGNDATA object.
+    \param cbRgnData size of the U_RGNDATA object.
+*/
+int rgndata_safe(
+      PU_RGNDATA rd,
+      int cbRgnData
+   ){
+   int count = rd->rdh.nCount;
+   if(4*count + (int)sizeof(U_RGNDATAHEADER) > cbRgnData)return(0);
+   return(1);
+}
+
+
+/**
+    \return 1 on success, 0 on failure
+    \brief Test a U_BITMAPINFO object.
+    \param Bmi  pointer to a U_BITMAPINFO object.
+    \param blimit    one byte past the end of the record.
+*/
+int bitmapinfo_safe(
+      const char *Bmi,
+      const char *blimit
+   ){
+   int       ClrUsed;
+   if(IS_MEM_UNSAFE(Bmi, offsetof(U_BITMAPINFO,bmiHeader) + sizeof(U_BITMAPINFOHEADER), blimit))return(0);
+   ClrUsed = get_real_color_count(Bmi + offsetof(U_BITMAPINFO,bmiHeader));
+   if(ClrUsed &&  IS_MEM_UNSAFE(Bmi, offsetof(U_BITMAPINFO,bmiColors) + ClrUsed*sizeof(U_RGBQUAD), blimit))return(0);
+   return(1);
+}
+
+/**
+    \brief Check that the bitmap in the specified DIB is compatible with the record size
+    
+    \return 1 on success, 0 on failure
+    \param record     EMF record that contains a DIB pixel array
+    \param iUsage     DIBcolors Enumeration
+    \param offBmi     offset from the start of the record to the start of the bitmapinfo structure
+    \param cbBmi      declared space for the bitmapinfo structure in the record
+    \param offBits    offset from the start of the record to the start of the bitmap
+    \param cbBits     declared space for the bitmap in the record (amount used may be less than this)
+    \param blimit     one byte past the end of the record.
+
+    This method can only test DIBs that hold Microsoft's various bitmap types.  PNG or JPG is just a bag
+    of bytes, and there is no possible way to derive from the known width and height how big it should be.
+*/
+int DIB_safe(
+       const char      *record,
+       uint32_t         iUsage,
+       uint32_t         offBmi,
+       uint32_t         cbBmi,
+       uint32_t         offBits,
+       uint32_t         cbBits,
+       const char      *blimit
+   ){
+   int  dibparams = U_BI_UNKNOWN;       // type of image not yet determined
+   const char      *px      = NULL;     // DIB pixels
+   const U_RGBQUAD *ct      = NULL;     // DIB color table
+   int              bs;
+   int              usedbytes;
+
+   if(!cbBmi)return(1);  // No DIB in a record where it is optional
+   if(IS_MEM_UNSAFE(record, offBmi + cbBmi, blimit))return(0);
+   if(!bitmapinfo_safe(record + offBmi, blimit))return(0);  // checks the number of colors
+   if(cbBits && IS_MEM_UNSAFE(record, offBits + cbBits, blimit))return(0);
+   if(iUsage == U_DIB_RGB_COLORS){
+       uint32_t width, height, colortype, numCt, invert; // these values will be set in get_DIB_params
+       // next call returns pointers and values, but allocates no memory
+       dibparams = get_DIB_params(record, offBits, offBmi, &px, (const U_RGBQUAD **) &ct,
+           &numCt, &width, &height, &colortype, &invert);
+
+       // sanity checking
+       if(numCt && colortype  >= U_BCBM_COLOR16)return(0);  //color tables not used above 16 bit pixels
+       if(!numCt && colortype < U_BCBM_COLOR16)return(0);   //color tables mandatory for < 16 bit
+ 
+       if(dibparams ==U_BI_RGB){  
+           // this is the only DIB type where we can calculate how big it should be when stored in the EMF file
+           bs = colortype/8;
+           if(bs<1){
+              usedbytes = (width*colortype + 7)/8;      // width of line in fully and partially occupied bytes
+           }
+           else {
+              usedbytes = width*bs;
+           }
+           if(IS_MEM_UNSAFE(record+offBits, usedbytes, blimit))return(0);
+       }
+   }
+   return(1);
+}
+
+
+/* **********************************************************************************************
+These functions contain shared code used by various U_EMR*_safe 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 all have this form:
+   
+   void core1_safe(const char *record){
+   
+   but some do not actually use torev.
+   
+   
+   
+*********************************************************************************************** */
+
+// all core*_safe call this, U_EMRSETMARGN_safe and some others all it directly
+// numbered as core5 to be consistent with uemf.c, but must appear before the others as there is no prototype
+// sizeof(U_ENHMETARECORD) bytes in the record
+int core5_safe(const char *record, int minSize){
+   PU_EMR pEmr = (PU_EMR)(record);
+   if((int) pEmr->nSize < minSize)return(0);
+   return(1);
+}
+
+// Functions with the same form starting with U_EMRPOLYBEZIER_safe
+int core1_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRPOLYLINETO))return(0);
+   PU_EMRPOLYLINETO pEmr = (PU_EMRPOLYLINETO) (record);
+   int count=pEmr->cptl;
+   const char *blimit = record + pEmr->emr.nSize;
+   if(IS_MEM_UNSAFE(pEmr->aptl, count*sizeof(U_POINTL), blimit))return(0);
+   return(1);
+}
+
+// Functions with the same form starting with U_EMRPOLYPOLYLINE_safe
+int core2_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRPOLYPOLYLINE))return(0);
+   PU_EMRPOLYPOLYLINE pEmr = (PU_EMRPOLYPOLYLINE) (record);
+   int count  = pEmr->cptl;
+   int nPolys = pEmr->nPolys;
+   const char * blimit = record + pEmr->emr.nSize;
+   if(IS_MEM_UNSAFE(pEmr->aPolyCounts, nPolys*4, blimit))return(0);
+   record += sizeof(U_EMRPOLYPOLYLINE) - 4 + sizeof(uint32_t)* nPolys;
+   if(IS_MEM_UNSAFE(record, count*sizeof(U_POINTL), blimit))return(0);
+   return(1);
+}
+
+
+// Functions with the same form starting with U_EMRSETMAPMODE_safe
+int core3_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRSETMAPMODE))return(0);
+   return(1);
+} 
+
+// Functions taking a single U_RECT or U_RECTL, starting with U_EMRELLIPSE_safe, also U_EMRFILLPATH_safe, 
+int core4_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRELLIPSE))return(0);
+   return(1);
+} 
+
+// Functions with the same form starting with U_EMRPOLYBEZIER16_safe
+int core6_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRPOLYBEZIER16))return(0);
+   PU_EMRPOLYBEZIER16 pEmr = (PU_EMRPOLYBEZIER16) (record);
+   int count=pEmr->cpts;
+   const char *blimit = record + pEmr->emr.nSize;
+   if(IS_MEM_UNSAFE(pEmr->apts, count*sizeof(U_POINT16), blimit))return(0);
+   return(1);
+} 
+
+
+// Records with the same form starting with U_EMRSETWINDOWEXTEX_safe, that is, all with two uint32_t values after the emr
+int core7_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRSETWINDOWEXTEX))return(0);
+   return(1);
+}
+
+// For U_EMREXTTEXTOUTA and U_EMREXTTEXTOUTW, type=0 for the first one
+int core8_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMREXTTEXTOUTA))return(0);
+   PU_EMREXTTEXTOUTA pEmr = (PU_EMREXTTEXTOUTA) (record);
+   const char *blimit = record + pEmr->emr.nSize;
+   if(!emrtext_safe(&(pEmr->emrtext),record,blimit))return(0);
+   return(1);
+} 
+
+// Functions that take a rect and a pair of points, starting with U_EMRARC_safe
+int core9_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRARC))return(0);
+   return(1);
+}
+
+// Functions with the same form starting with U_EMRPOLYPOLYLINE16_safe
+int core10_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRPOLYPOLYLINE16))return(0);
+   PU_EMRPOLYPOLYLINE16 pEmr = (PU_EMRPOLYPOLYLINE16) (record);
+   int count = pEmr->cpts;
+   int nPolys = pEmr->nPolys;
+   const char *blimit = record + pEmr->emr.nSize;
+   if(IS_MEM_UNSAFE(pEmr->aPolyCounts, nPolys*4, blimit))return(0);
+   record += sizeof(U_EMRPOLYPOLYLINE16) - 4 + sizeof(uint32_t)* nPolys;
+   if(IS_MEM_UNSAFE(record, count*sizeof(U_POINT16), blimit))return(0);
+   return(1);
+} 
+
+// Functions with the same form starting with  U_EMRINVERTRGN_safe and U_EMRPAINTRGN_safe,
+int core11_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRINVERTRGN))return(0);
+   PU_EMRINVERTRGN pEmr = (PU_EMRINVERTRGN)(record);
+   int cbRgnData = pEmr->cbRgnData;
+   const char *blimit = record + pEmr->emr.nSize;
+   if(IS_MEM_UNSAFE(pEmr->RgnData, cbRgnData, blimit))return(0);
+   return(rgndata_safe(pEmr->RgnData, cbRgnData));
+} 
+
+
+// common code for U_EMRCREATEMONOBRUSH_safe and U_EMRCREATEDIBPATTERNBRUSHPT_safe,
+int core12_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRCREATEMONOBRUSH))return(0);
+   PU_EMRCREATEMONOBRUSH pEmr = (PU_EMRCREATEMONOBRUSH) (record);
+   const char *blimit = record + pEmr->emr.nSize;
+   U_OFFBMI  offBmi   = pEmr->offBmi;
+   U_CBBMI   cbBmi    = pEmr->cbBmi;
+   U_OFFBITS offBits  = pEmr->offBits;
+   U_CBBITS  cbBits   = pEmr->cbBits;
+   uint32_t  iUsage   = pEmr->iUsage;
+   return(DIB_safe(record, iUsage, offBmi, cbBmi, offBits, cbBits, blimit));
+}
+
+// common code for U_EMRALPHABLEND_safe and U_EMRTRANSPARENTBLT_safe,
+int core13_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRALPHABLEND))return(0);
+   PU_EMRALPHABLEND pEmr = (PU_EMRALPHABLEND) (record);
+   const char *blimit      = record + pEmr->emr.nSize;
+   U_OFFBMISRC  offBmiSrc  = pEmr->offBmiSrc;
+   U_CBBMISRC   cbBmiSrc   = pEmr->cbBmiSrc; 
+   U_OFFBITSSRC offBitsSrc = pEmr->offBitsSrc;
+   U_CBBITS     cbBitsSrc  = pEmr->cbBitsSrc;
+   uint32_t     iUsageSrc   = pEmr->iUsageSrc;
+   return(DIB_safe(record, iUsageSrc, offBmiSrc, cbBmiSrc, offBitsSrc, cbBitsSrc, blimit));
+}
+
+/* **********************************************************************************************
+These are the core EMR_safe functions, each converts a particular type of record.  
+All operate in place on the chunk of memory holding that record.
+Some of these have offsets or counts which, if corrupt or evil would result in access outside
+  the record.  These cases return a status value of 0 if that happens, 1 on success.  Other
+  records which do not have these issues do not return a status value.
+They are listed in order by the corresponding U_EMR_* index number.  
+*********************************************************************************************** */
+
+/**
+    All of the record level (hidden) functions have this form:
+    \brief Convert a pointer to a U_EMR_whatever record which has not been implemented.
+    \param record   pointer to a buffer holding the EMR record
+    \param torev    1 for native to reversed, 0 for reversed to native
+*/
+int U_EMRNOTIMPLEMENTED_safe(const char *record){
+   fprintf(stderr,"EMF WARNING:  could not safety check record because that type has not been implemented!\n");
+   return(core5_safe(record, sizeof(U_EMR)));
+}
+
+// U_EMRHEADER                1
+int U_EMRHEADER_safe(const char *record){
+   // use _MIN form so that it accepts very old EMF files
+   return(core5_safe(record, U_SIZE_EMRHEADER_MIN));
+}
+
+// U_EMRPOLYBEZIER                       2
+int U_EMRPOLYBEZIER_safe(const char *record){
+   return(core1_safe(record));
+} 
+
+// U_EMRPOLYGON                          3
+int U_EMRPOLYGON_safe(const char *record){
+   return(core1_safe(record));
+} 
+
+// U_EMRPOLYLINE              4
+int U_EMRPOLYLINE_safe(const char *record){
+   return(core1_safe(record));
+} 
+
+// U_EMRPOLYBEZIERTO          5
+int U_EMRPOLYBEZIERTO_safe(const char *record){
+   return(core1_safe(record));
+} 
+
+// U_EMRPOLYLINETO            6
+int U_EMRPOLYLINETO_safe(const char *record){
+   return(core1_safe(record));
+} 
+
+// U_EMRPOLYPOLYLINE          7
+int U_EMRPOLYPOLYLINE_safe(const char *record){
+   return(core2_safe(record));
+} 
+
+// U_EMRPOLYPOLYGON           8
+int U_EMRPOLYPOLYGON_safe(const char *record){
+   return(core2_safe(record));
+} 
+
+// U_EMRSETWINDOWEXTEX        9
+int U_EMRSETWINDOWEXTEX_safe(const char *record){
+   return(core7_safe(record));
+} 
+
+// U_EMRSETWINDOWORGEX       10
+int U_EMRSETWINDOWORGEX_safe(const char *record){
+   return(core7_safe(record));
+} 
+
+// U_EMRSETVIEWPORTEXTEX     11
+int U_EMRSETVIEWPORTEXTEX_safe(const char *record){
+   return(core7_safe(record));
+} 
+
+// U_EMRSETVIEWPORTORGEX     12
+int U_EMRSETVIEWPORTORGEX_safe(const char *record){
+   return(core7_safe(record));
+} 
+
+// U_EMRSETBRUSHORGEX        13
+int U_EMRSETBRUSHORGEX_safe(const char *record){
+   return(core7_safe(record));
+} 
+
+// U_EMREOF                  14
+int U_EMREOF_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMREOF))return(0);
+   PU_EMREOF pEmr = (PU_EMREOF)(record);
+   const char *blimit = record + pEmr->emr.nSize;
+   int cbPalEntries=pEmr->cbPalEntries;
+   if(cbPalEntries){
+      if(IS_MEM_UNSAFE(record, pEmr->offPalEntries + 2*2, blimit))return(0);// 2 16 bit values in U_LOGPALLETE
+   }
+   int off = sizeof(U_EMREOF) + 4 * cbPalEntries;
+   if(IS_MEM_UNSAFE(record, off + 4, blimit))return(0);
+   return(1);
+} 
+
+
+// U_EMRSETPIXELV            15
+int U_EMRSETPIXELV_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRSETPIXELV));
+
+} 
+
+
+// U_EMRSETMAPPERFLAGS       16
+int U_EMRSETMAPPERFLAGS_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRSETMAPPERFLAGS));
+} 
+
+
+// U_EMRSETMAPMODE           17
+int U_EMRSETMAPMODE_safe(const char *record){
+   return(core3_safe(record));
+}
+
+// U_EMRSETBKMODE            18
+int U_EMRSETBKMODE_safe(const char *record){
+   return(core3_safe(record));
+}
+
+// U_EMRSETPOLYFILLMODE      19
+int U_EMRSETPOLYFILLMODE_safe(const char *record){
+   return(core3_safe(record));
+}
+
+// U_EMRSETROP2              20
+int U_EMRSETROP2_safe(const char *record){
+   return(core3_safe(record));
+}
+
+// U_EMRSETSTRETCHBLTMODE    21
+int U_EMRSETSTRETCHBLTMODE_safe(const char *record){
+   return(core3_safe(record));
+}
+
+// U_EMRSETTEXTALIGN         22
+int U_EMRSETTEXTALIGN_safe(const char *record){
+   return(core3_safe(record));
+}
+
+// U_EMRSETCOLORADJUSTMENT   23
+int U_EMRSETCOLORADJUSTMENT_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRSETCOLORADJUSTMENT));
+}
+
+// U_EMRSETTEXTCOLOR         24
+int U_EMRSETTEXTCOLOR_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRSETTEXTCOLOR));
+}
+
+// U_EMRSETBKCOLOR           25
+int U_EMRSETBKCOLOR_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRSETBKCOLOR));
+}
+
+// U_EMROFFSETCLIPRGN        26
+int U_EMROFFSETCLIPRGN_safe(const char *record){
+   return(core7_safe(record));
+} 
+
+// U_EMRMOVETOEX             27
+int U_EMRMOVETOEX_safe(const char *record){
+   return(core7_safe(record));
+} 
+
+// U_EMRSETMETARGN           28
+int U_EMRSETMETARGN_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRSETMETARGN));
+}
+
+// U_EMREXCLUDECLIPRECT      29
+int U_EMREXCLUDECLIPRECT_safe(const char *record){
+   return(core4_safe(record));
+}
+
+// U_EMRINTERSECTCLIPRECT    30
+int U_EMRINTERSECTCLIPRECT_safe(const char *record){
+   return(core4_safe(record));
+}
+
+// U_EMRSCALEVIEWPORTEXTEX   31
+int U_EMRSCALEVIEWPORTEXTEX_safe(const char *record){
+   return(core4_safe(record));
+}
+
+// U_EMRSCALEWINDOWEXTEX     32
+int U_EMRSCALEWINDOWEXTEX_safe(const char *record){
+   return(core4_safe(record));
+}
+
+// U_EMRSAVEDC               33
+int U_EMRSAVEDC_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRSAVEDC));
+}
+
+// U_EMRRESTOREDC            34
+int U_EMRRESTOREDC_safe(const char *record){
+   return(core3_safe(record));
+}
+
+// U_EMRSETWORLDTRANSFORM    35
+int U_EMRSETWORLDTRANSFORM_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRSETWORLDTRANSFORM));
+} 
+
+// U_EMRMODIFYWORLDTRANSFORM 36
+int U_EMRMODIFYWORLDTRANSFORM_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRMODIFYWORLDTRANSFORM));
+} 
+
+// U_EMRSELECTOBJECT         37
+int U_EMRSELECTOBJECT_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRSELECTOBJECT));
+} 
+
+// U_EMRCREATEPEN            38
+int U_EMRCREATEPEN_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRCREATEPEN));
+} 
+
+// U_EMRCREATEBRUSHINDIRECT  39
+int U_EMRCREATEBRUSHINDIRECT_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRCREATEBRUSHINDIRECT));
+} 
+
+// U_EMRDELETEOBJECT         40
+int U_EMRDELETEOBJECT_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRDELETEOBJECT));
+
+} 
+
+// U_EMRANGLEARC             41
+int U_EMRANGLEARC_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRANGLEARC));
+} 
+
+// U_EMRELLIPSE              42
+int U_EMRELLIPSE_safe(const char *record){
+   return(core4_safe(record));
+}
+
+// U_EMRRECTANGLE            43
+int U_EMRRECTANGLE_safe(const char *record){
+   return(core4_safe(record));
+}
+
+// U_EMRROUNDRECT            44
+int U_EMRROUNDRECT_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRROUNDRECT));
+}
+
+// U_EMRARC                  45
+int U_EMRARC_safe(const char *record){
+   return(core9_safe(record));
+}
+
+// U_EMRCHORD                46
+int U_EMRCHORD_safe(const char *record){
+   return(core9_safe(record));
+}
+
+// U_EMRPIE                  47
+int U_EMRPIE_safe(const char *record){
+   return(core9_safe(record));
+}
+
+// U_EMRSELECTPALETTE        48
+int U_EMRSELECTPALETTE_safe(const char *record){
+   return(core3_safe(record));
+}
+
+// U_EMRCREATEPALETTE        49
+int U_EMRCREATEPALETTE_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRCREATEPALETTE));
+}
+
+// U_EMRSETPALETTEENTRIES    50
+int U_EMRSETPALETTEENTRIES_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRSETPALETTEENTRIES));
+}
+
+// U_EMRRESIZEPALETTE        51
+int U_EMRRESIZEPALETTE_safe(const char *record){
+   return(core7_safe(record));
+} 
+
+// U_EMRREALIZEPALETTE       52
+int U_EMRREALIZEPALETTE_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRREALIZEPALETTE));
+}
+
+// U_EMREXTFLOODFILL         53
+int U_EMREXTFLOODFILL_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMREXTFLOODFILL));
+}
+
+// U_EMRLINETO               54
+int U_EMRLINETO_safe(const char *record){
+   return(core7_safe(record));
+} 
+
+// U_EMRARCTO                55
+int U_EMRARCTO_safe(const char *record){
+   return(core9_safe(record));
+}
+
+// U_EMRPOLYDRAW             56
+int U_EMRPOLYDRAW_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRPOLYDRAW))return(0);
+   PU_EMRPOLYDRAW pEmr = (PU_EMRPOLYDRAW)(record);
+   int count = pEmr->cptl;
+   const char *blimit = record + pEmr->emr.nSize;
+   if(IS_MEM_UNSAFE(pEmr->aptl, count*sizeof(U_POINTL), blimit))return(0);
+   return(1);
+}
+
+// U_EMRSETARCDIRECTION      57
+int U_EMRSETARCDIRECTION_safe(const char *record){
+   return(core3_safe(record));
+}
+
+// U_EMRSETMITERLIMIT        58
+int U_EMRSETMITERLIMIT_safe(const char *record){
+   return(core3_safe(record));
+}
+
+
+// U_EMRBEGINPATH            59
+int U_EMRBEGINPATH_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRBEGINPATH));
+}
+
+// U_EMRENDPATH              60
+int U_EMRENDPATH_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRENDPATH));
+}
+
+// U_EMRCLOSEFIGURE          61
+int U_EMRCLOSEFIGURE_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRCLOSEFIGURE));
+}
+
+// U_EMRFILLPATH             62
+int U_EMRFILLPATH_safe(const char *record){
+   return(core4_safe(record));
+}
+
+// U_EMRSTROKEANDFILLPATH    63
+int U_EMRSTROKEANDFILLPATH_safe(const char *record){
+   return(core4_safe(record));
+}
+
+// U_EMRSTROKEPATH           64
+int U_EMRSTROKEPATH_safe(const char *record){
+   return(core4_safe(record));
+}
+
+// U_EMRFLATTENPATH          65
+int U_EMRFLATTENPATH_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRFLATTENPATH));
+}
+
+// U_EMRWIDENPATH            66
+int U_EMRWIDENPATH_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRWIDENPATH));
+}
+
+// U_EMRSELECTCLIPPATH       67
+int U_EMRSELECTCLIPPATH_safe(const char *record){
+   return(core3_safe(record));
+}
+
+// U_EMRABORTPATH            68
+int U_EMRABORTPATH_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRABORTPATH));
+}
+
+// U_EMRUNDEF69                       69
+#define U_EMRUNDEF69_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+
+// U_EMRCOMMENT              70  Comment (any binary data, interpretation is program specific)
+int U_EMRCOMMENT_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRCOMMENT))return(0);
+   PU_EMRCOMMENT pEmr = (PU_EMRCOMMENT)(record);
+   int cbData = pEmr->cbData;
+   const char *blimit =record + pEmr->emr.nSize;
+   if(IS_MEM_UNSAFE(record, cbData + sizeof(U_SIZE_EMRCOMMENT), blimit))return(0);
+   return(1);
+} 
+
+// U_EMRFILLRGN              71
+int U_EMRFILLRGN_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRFILLRGN))return(0);
+   PU_EMRFILLRGN pEmr = (PU_EMRFILLRGN)(record);
+   int cbRgnData = pEmr->cbRgnData;
+   const char *blimit = record + pEmr->emr.nSize;
+   if(IS_MEM_UNSAFE(pEmr->RgnData, cbRgnData, blimit))return(0);
+   return(rgndata_safe(pEmr->RgnData, cbRgnData));
+} 
+
+// U_EMRFRAMERGN             72
+int U_EMRFRAMERGN_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRFRAMERGN))return(0);
+   PU_EMRFRAMERGN pEmr = (PU_EMRFRAMERGN)(record);
+   int cbRgnData = pEmr->cbRgnData;
+   const char *blimit =  record + pEmr->emr.nSize;
+   if(IS_MEM_UNSAFE(pEmr->RgnData, cbRgnData, blimit))return(0);
+   return(rgndata_safe(pEmr->RgnData, cbRgnData));
+} 
+
+// U_EMRINVERTRGN            73
+int U_EMRINVERTRGN_safe(const char *record){
+   return(core11_safe(record));
+}
+
+// U_EMRPAINTRGN             74
+int U_EMRPAINTRGN_safe(const char *record){
+   return(core11_safe(record));
+}
+
+// U_EMREXTSELECTCLIPRGN     75
+int U_EMREXTSELECTCLIPRGN_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMREXTSELECTCLIPRGN))return(0);
+   PU_EMREXTSELECTCLIPRGN pEmr = (PU_EMREXTSELECTCLIPRGN)(record);
+   int cbRgnData = pEmr->cbRgnData;
+   /* data size can be 0 with COPY mode, it means clear the clip region. */
+   if(pEmr->iMode == U_RGN_COPY && !cbRgnData)return(1);
+   const char *blimit = record + pEmr->emr.nSize;
+   if(IS_MEM_UNSAFE(pEmr->RgnData, cbRgnData, blimit))return(0);
+   return(rgndata_safe(pEmr->RgnData, cbRgnData));
+} 
+
+// U_EMRBITBLT               76
+int U_EMRBITBLT_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRBITBLT))return(0);
+   PU_EMRBITBLT pEmr = (PU_EMRBITBLT) (record);
+   const char *blimit      = record + pEmr->emr.nSize;
+   U_OFFBMISRC  offBmiSrc  = pEmr->offBmiSrc;
+   U_CBBMISRC   cbBmiSrc   = pEmr->cbBmiSrc; 
+   U_OFFBITSSRC offBitsSrc = pEmr->offBitsSrc;
+   U_CBBITS     cbBitsSrc  = pEmr->cbBitsSrc;
+   uint32_t     iUsageSrc  = pEmr->iUsageSrc;
+   return(DIB_safe(record, iUsageSrc, offBmiSrc, cbBmiSrc, offBitsSrc, cbBitsSrc, blimit));
+}
+
+// U_EMRSTRETCHBLT           77
+int U_EMRSTRETCHBLT_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRSTRETCHBLT))return(0);
+   PU_EMRBITBLT pEmr = (PU_EMRBITBLT) (record);
+   const char *blimit      = record + pEmr->emr.nSize;
+   U_OFFBMISRC  offBmiSrc  = pEmr->offBmiSrc;
+   U_CBBMISRC   cbBmiSrc   = pEmr->cbBmiSrc; 
+   U_OFFBITSSRC offBitsSrc = pEmr->offBitsSrc;
+   U_CBBITS     cbBitsSrc  = pEmr->cbBitsSrc;
+   uint32_t     iUsageSrc  = pEmr->iUsageSrc;
+   return(DIB_safe(record, iUsageSrc, offBmiSrc, cbBmiSrc, offBitsSrc, cbBitsSrc, blimit));
+}
+
+// U_EMRMASKBLT              78
+int U_EMRMASKBLT_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRMASKBLT))return(0);
+   PU_EMRMASKBLT pEmr = (PU_EMRMASKBLT) (record);
+   const char *blimit       = record + pEmr->emr.nSize;
+   U_OFFBMISRC  offBmiSrc   = pEmr->offBmiSrc;
+   U_CBBMISRC   cbBmiSrc    = pEmr->cbBmiSrc;
+   U_OFFBMIMSK  offBmiMask  = pEmr->offBmiMask;
+   U_CBBMIMSK   cbBmiMask   = pEmr->cbBmiMask;
+   U_OFFBITSSRC offBitsSrc  = pEmr->offBitsSrc;
+   U_CBBITSSRC  cbBitsSrc   = pEmr->cbBitsSrc;
+   U_OFFBITSMSK offBitsMask = pEmr->offBitsMask;
+   U_CBBITSMSK  cbBitsMask  = pEmr->cbBitsMask;
+   uint32_t     iUsageSrc  = pEmr->iUsageSrc;
+   uint32_t     iUsageMask  = pEmr->iUsageMask;
+   if(!DIB_safe(record, iUsageSrc, offBmiSrc, cbBmiSrc, offBitsSrc, cbBitsSrc, blimit))return(0);
+   return(DIB_safe(record, iUsageMask, offBmiMask, cbBmiMask, offBitsMask, cbBitsMask, blimit));
+}
+
+// U_EMRPLGBLT               79
+int U_EMRPLGBLT_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRPLGBLT))return(0);
+   PU_EMRPLGBLT pEmr = (PU_EMRPLGBLT) (record);
+   const char *blimit       = record + pEmr->emr.nSize;
+   U_OFFBMISRC  offBmiSrc   = pEmr->offBmiSrc;
+   U_CBBMISRC   cbBmiSrc    = pEmr->cbBmiSrc;
+   U_OFFBMIMSK  offBmiMask  = pEmr->offBmiMask;
+   U_CBBMIMSK   cbBmiMask   = pEmr->cbBmiMask;
+   U_OFFBITSSRC offBitsSrc  = pEmr->offBitsSrc;
+   U_CBBITSSRC  cbBitsSrc   = pEmr->cbBitsSrc;
+   U_OFFBITSMSK offBitsMask = pEmr->offBitsMask;
+   U_CBBITSMSK  cbBitsMask  = pEmr->cbBitsMask;
+   uint32_t     iUsageSrc  = pEmr->iUsageSrc;
+   uint32_t     iUsageMask  = pEmr->iUsageMask;
+   if(!DIB_safe(record, iUsageSrc, offBmiSrc, cbBmiSrc, offBitsSrc, cbBitsSrc, blimit))return(0);
+   return(DIB_safe(record, iUsageMask, offBmiMask, cbBmiMask, offBitsMask, cbBitsMask, blimit));
+}
+
+// U_EMRSETDIBITSTODEVICE    80
+int U_EMRSETDIBITSTODEVICE_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRSETDIBITSTODEVICE))return(0);
+   PU_EMRSETDIBITSTODEVICE pEmr = (PU_EMRSETDIBITSTODEVICE) (record);
+   const char *blimit       = record + pEmr->emr.nSize;
+   U_OFFBMISRC  offBmiSrc   = pEmr->offBmiSrc;
+   U_CBBMISRC   cbBmiSrc    = pEmr->cbBmiSrc;
+   U_OFFBITSSRC offBitsSrc  = pEmr->offBitsSrc;
+   U_CBBITSSRC  cbBitsSrc   = pEmr->cbBitsSrc;
+   uint32_t     iUsageSrc  = pEmr->iUsageSrc;
+   return(DIB_safe(record, iUsageSrc, offBmiSrc, cbBmiSrc, offBitsSrc, cbBitsSrc, blimit));
+}
+
+// U_EMRSTRETCHDIBITS        81
+int U_EMRSTRETCHDIBITS_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRSTRETCHDIBITS))return(0);
+   PU_EMRSTRETCHDIBITS pEmr = (PU_EMRSTRETCHDIBITS) (record);
+   const char *blimit       = record + pEmr->emr.nSize;
+   U_OFFBMISRC  offBmiSrc   = pEmr->offBmiSrc;
+   U_CBBMISRC   cbBmiSrc    = pEmr->cbBmiSrc;
+   U_OFFBITSSRC offBitsSrc  = pEmr->offBitsSrc;
+   U_CBBITSSRC  cbBitsSrc   = pEmr->cbBitsSrc;
+   uint32_t     iUsageSrc  = pEmr->iUsageSrc;
+   return(DIB_safe(record, iUsageSrc, offBmiSrc, cbBmiSrc, offBitsSrc, cbBitsSrc, blimit));
+}
+
+// U_EMREXTCREATEFONTINDIRECTW    82
+int U_EMREXTCREATEFONTINDIRECTW_safe(const char *record){
+   /* Panose or logfont, LogFontExDv is not supported.  Test smallest to largest */
+   if(core5_safe(record, U_SIZE_EMREXTCREATEFONTINDIRECTW_LOGFONT))return(1);
+   return(core5_safe(record, U_SIZE_EMREXTCREATEFONTINDIRECTW_LOGFONT_PANOSE));
+}
+
+// U_EMREXTTEXTOUTA          83
+int U_EMREXTTEXTOUTA_safe(const char *record){
+   return(core8_safe(record));
+}
+
+// U_EMREXTTEXTOUTW          84
+int U_EMREXTTEXTOUTW_safe(const char *record){
+   return(core8_safe(record));
+}
+
+// U_EMRPOLYBEZIER16         85
+/**
+    \brief Convert a pointer to a U_EMR_POLYBEZIER16 record.
+    \param record   pointer to a buffer holding the EMR record
+*/
+int U_EMRPOLYBEZIER16_safe(const char *record){
+   return(core6_safe(record));
+}
+
+// U_EMRPOLYGON16            86
+int U_EMRPOLYGON16_safe(const char *record){
+   return(core6_safe(record));
+}
+
+// U_EMRPOLYLINE16           87
+int U_EMRPOLYLINE16_safe(const char *record){
+   return(core6_safe(record));
+}
+
+// U_EMRPOLYBEZIERTO16       88
+int U_EMRPOLYBEZIERTO16_safe(const char *record){
+   return(core6_safe(record));
+}
+
+// U_EMRPOLYLINETO16         89
+/**
+    \brief Convert a pointer to a U_EMR_POLYLINETO16 record.
+    \param record   pointer to a buffer holding the EMR record
+*/
+int U_EMRPOLYLINETO16_safe(const char *record){
+   return(core6_safe(record));
+}
+
+// U_EMRPOLYPOLYLINE16       90
+int U_EMRPOLYPOLYLINE16_safe(const char *record){
+   return(core10_safe(record));
+}
+
+// U_EMRPOLYPOLYGON16        91
+int U_EMRPOLYPOLYGON16_safe(const char *record){
+   return(core10_safe(record));
+}
+
+
+// U_EMRPOLYDRAW16           92
+int U_EMRPOLYDRAW16_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRPOLYDRAW16))return(0);
+   PU_EMRPOLYDRAW16 pEmr = (PU_EMRPOLYDRAW16)(record);
+   int count = pEmr->cpts;
+   const char *blimit = record + pEmr->emr.nSize;
+   if(IS_MEM_UNSAFE(pEmr->apts, count*sizeof(U_POINT16), blimit))return(0);
+   return(1);
+}
+
+// U_EMRCREATEMONOBRUSH      93
+int U_EMRCREATEMONOBRUSH_safe(const char *record){
+   return(core12_safe(record));
+}
+
+// U_EMRCREATEDIBPATTERNBRUSHPT_safe   94
+int U_EMRCREATEDIBPATTERNBRUSHPT_safe(const char *record){
+   return(core12_safe(record));
+}
+
+
+// U_EMREXTCREATEPEN         95
+int U_EMREXTCREATEPEN_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMREXTCREATEPEN))return(0);
+   PU_EMREXTCREATEPEN pEmr = (PU_EMREXTCREATEPEN)(record);
+   const char *blimit     = record + pEmr->emr.nSize;
+   U_OFFBMI     offBmi  = pEmr->offBmi;
+   U_CBBMI      cbBmi   = pEmr->cbBmi;
+   U_OFFBITS    offBits = pEmr->offBits;
+   U_CBBITS     cbBits  = pEmr->cbBits;
+   if(!DIB_safe(record, U_DIB_RGB_COLORS, offBmi, cbBmi, offBits, cbBits, blimit))return(0);
+   return(extlogpen_safe((PU_EXTLOGPEN) &(pEmr->elp), blimit)); 
+}
+
+// U_EMRPOLYTEXTOUTA         96 NOT IMPLEMENTED, denigrated after Windows NT
+#define U_EMRPOLYTEXTOUTA_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+// U_EMRPOLYTEXTOUTW         97 NOT IMPLEMENTED, denigrated after Windows NT
+#define U_EMRPOLYTEXTOUTW_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+
+// U_EMRSETICMMODE           98
+int U_EMRSETICMMODE_safe(const char *record){
+   return(core3_safe(record));
+}
+
+// U_EMRCREATECOLORSPACE     99
+int U_EMRCREATECOLORSPACE_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRCREATECOLORSPACE));
+}
+
+// U_EMRSETCOLORSPACE       100
+int U_EMRSETCOLORSPACE_safe(const char *record){
+   return(core3_safe(record));
+}
+
+// U_EMRDELETECOLORSPACE    101
+int U_EMRDELETECOLORSPACE_safe(const char *record){
+   return(core3_safe(record));
+}
+
+// U_EMRGLSRECORD           102  Not implemented
+#define U_EMRGLSRECORD_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+// U_EMRGLSBOUNDEDRECORD    103  Not implemented
+#define U_EMRGLSBOUNDEDRECORD_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+
+// U_EMRPIXELFORMAT         104
+int U_EMRPIXELFORMAT_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRPIXELFORMAT));
+}
+
+// U_EMRDRAWESCAPE          105  Not implemented
+#define U_EMRDRAWESCAPE_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+// U_EMREXTESCAPE           106  Not implemented
+#define U_EMREXTESCAPE_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+// U_EMRUNDEF107            107  Not implemented
+#define U_EMRUNDEF107_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+
+// U_EMRSMALLTEXTOUT        108
+int U_EMRSMALLTEXTOUT_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRSMALLTEXTOUT))return(0);
+   PU_EMRSMALLTEXTOUT pEmr = (PU_EMRSMALLTEXTOUT)(record);
+   int roff=sizeof(U_EMRSMALLTEXTOUT);        // offset to the start of the variable fields
+   int fuOptions = pEmr->fuOptions;
+   int cChars = pEmr->cChars;
+   const char *blimit = record + pEmr->emr.nSize;
+   if(!(fuOptions & U_ETO_NO_RECT)){
+      if(IS_MEM_UNSAFE(record, roff + sizeof(U_RECTL), blimit))return(0);
+   }
+   if(IS_MEM_UNSAFE(record, roff + sizeof(U_RECTL) + cChars, blimit))return(0);
+   return(1);
+}
+
+// U_EMRFORCEUFIMAPPING     109  Not implemented
+#define U_EMRFORCEUFIMAPPING_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+// U_EMRNAMEDESCAPE         110  Not implemented
+#define U_EMRNAMEDESCAPE_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+// U_EMRCOLORCORRECTPALETTE 111  Not implemented
+#define U_EMRCOLORCORRECTPALETTE_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+// U_EMRSETICMPROFILEA      112  Not implemented
+#define U_EMRSETICMPROFILEA_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+// U_EMRSETICMPROFILEW      113  Not implemented
+#define U_EMRSETICMPROFILEW_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+
+// U_EMRALPHABLEND          114
+int U_EMRALPHABLEND_safe(const char *record){
+   return(core13_safe(record));
+}
+
+// U_EMRSETLAYOUT           115
+int U_EMRSETLAYOUT_safe(const char *record){
+   return(core3_safe(record));
+}
+
+// U_EMRTRANSPARENTBLT      116
+int U_EMRTRANSPARENTBLT_safe(const char *record){
+   return(core13_safe(record));
+}
+
+
+// U_EMRUNDEF117            117  Not implemented
+#define U_EMRUNDEF117_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+// U_EMRGRADIENTFILL        118
+int U_EMRGRADIENTFILL_safe(const char *record){
+   if(!core5_safe(record, U_SIZE_EMRGRADIENTFILL))return(0);
+   PU_EMRGRADIENTFILL pEmr = (PU_EMRGRADIENTFILL)(record);
+   int nTriVert = pEmr->nTriVert;
+   int nGradObj = pEmr->nGradObj;
+   int ulMode   = pEmr->ulMode;
+   const char *blimit = record + pEmr->emr.nSize;
+   if(IS_MEM_UNSAFE(record, nTriVert*sizeof(U_TRIVERTEX), blimit))return(0);
+   record += nTriVert * sizeof(U_TRIVERTEX);
+   if(nGradObj){
+      if(     ulMode == U_GRADIENT_FILL_TRIANGLE){
+         if(IS_MEM_UNSAFE(record, nGradObj*sizeof(U_GRADIENT3), blimit))return(0);
+      }
+      else if(ulMode == U_GRADIENT_FILL_RECT_H || ulMode == U_GRADIENT_FILL_RECT_V){
+         if(IS_MEM_UNSAFE(record, nGradObj*sizeof(U_GRADIENT4), blimit))return(0);
+      }
+   }
+   return(1);
+}
+
+// U_EMRSETLINKEDUFIS       119  Not implemented
+#define U_EMRSETLINKEDUFIS_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+// U_EMRSETTEXTJUSTIFICATION120  Not implemented (denigrated)
+#define U_EMRSETTEXTJUSTIFICATION_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+// U_EMRCOLORMATCHTOTARGETW 121  Not implemented  
+#define U_EMRCOLORMATCHTOTARGETW_safe(A) U_EMRNOTIMPLEMENTED_safe(A) //!< Not implemented.
+
+// U_EMRCREATECOLORSPACEW   122
+int U_EMRCREATECOLORSPACEW_safe(const char *record){
+   return(core5_safe(record, U_SIZE_EMRCREATECOLORSPACEW));
+}
+
+//! \endcond
+
+/**
+    \brief Test an EMF record in memory from Big Endian to Little Endian.
+    \return 0 on failure, 1 on success
+    \param record   pointer to the EMF record in memory
+    
+    Normally this would be called immediately after reading a record from a file
+      and having called U_emf_record_sizeok().  
+    It is NOT safe to call this routine without first calling U_emf_record_sizeok)()!
+    If the file has been converted from one endian to another calling this routine is
+      not necessary, because those routines also perform these checks.
+*/
+int U_emf_record_safe(const char *record){
+    int rstatus=1;
+    
+    if(!record)return(0);  // programming error
+
+    switch (U_EMRTYPE(record))
+    {
+        case U_EMR_HEADER:                  rstatus=U_EMRHEADER_safe(record);                  break;
+        case U_EMR_POLYBEZIER:              rstatus=U_EMRPOLYBEZIER_safe(record);              break;
+        case U_EMR_POLYGON:                 rstatus=U_EMRPOLYGON_safe(record);                 break;
+        case U_EMR_POLYLINE:                rstatus=U_EMRPOLYLINE_safe(record);                break;
+        case U_EMR_POLYBEZIERTO:            rstatus=U_EMRPOLYBEZIERTO_safe(record);            break;
+        case U_EMR_POLYLINETO:              rstatus=U_EMRPOLYLINETO_safe(record);              break;
+        case U_EMR_POLYPOLYLINE:            rstatus=U_EMRPOLYPOLYLINE_safe(record);            break;
+        case U_EMR_POLYPOLYGON:             rstatus=U_EMRPOLYPOLYGON_safe(record);             break;
+        case U_EMR_SETWINDOWEXTEX:          rstatus=U_EMRSETWINDOWEXTEX_safe(record);          break;
+        case U_EMR_SETWINDOWORGEX:          rstatus=U_EMRSETWINDOWORGEX_safe(record);          break;
+        case U_EMR_SETVIEWPORTEXTEX:        rstatus=U_EMRSETVIEWPORTEXTEX_safe(record);        break;
+        case U_EMR_SETVIEWPORTORGEX:        rstatus=U_EMRSETVIEWPORTORGEX_safe(record);        break;
+        case U_EMR_SETBRUSHORGEX:           rstatus=U_EMRSETBRUSHORGEX_safe(record);           break;
+        case U_EMR_EOF:                     rstatus=U_EMREOF_safe(record);                     break;
+        case U_EMR_SETPIXELV:               rstatus=U_EMRSETPIXELV_safe(record);               break;
+        case U_EMR_SETMAPPERFLAGS:          rstatus=U_EMRSETMAPPERFLAGS_safe(record);          break;
+        case U_EMR_SETMAPMODE:              rstatus=U_EMRSETMAPMODE_safe(record);              break;
+        case U_EMR_SETBKMODE:               rstatus=U_EMRSETBKMODE_safe(record);               break;
+        case U_EMR_SETPOLYFILLMODE:         rstatus=U_EMRSETPOLYFILLMODE_safe(record);         break;
+        case U_EMR_SETROP2:                 rstatus=U_EMRSETROP2_safe(record);                 break;
+        case U_EMR_SETSTRETCHBLTMODE:       rstatus=U_EMRSETSTRETCHBLTMODE_safe(record);       break;
+        case U_EMR_SETTEXTALIGN:            rstatus=U_EMRSETTEXTALIGN_safe(record);            break;
+        case U_EMR_SETCOLORADJUSTMENT:      rstatus=U_EMRSETCOLORADJUSTMENT_safe(record);      break;
+        case U_EMR_SETTEXTCOLOR:            rstatus=U_EMRSETTEXTCOLOR_safe(record);            break;
+        case U_EMR_SETBKCOLOR:              rstatus=U_EMRSETBKCOLOR_safe(record);              break;
+        case U_EMR_OFFSETCLIPRGN:           rstatus=U_EMROFFSETCLIPRGN_safe(record);           break;
+        case U_EMR_MOVETOEX:                rstatus=U_EMRMOVETOEX_safe(record);                break;
+        case U_EMR_SETMETARGN:              rstatus=U_EMRSETMETARGN_safe(record);              break;
+        case U_EMR_EXCLUDECLIPRECT:         rstatus=U_EMREXCLUDECLIPRECT_safe(record);         break;
+        case U_EMR_INTERSECTCLIPRECT:       rstatus=U_EMRINTERSECTCLIPRECT_safe(record);       break;
+        case U_EMR_SCALEVIEWPORTEXTEX:      rstatus=U_EMRSCALEVIEWPORTEXTEX_safe(record);      break;
+        case U_EMR_SCALEWINDOWEXTEX:        rstatus=U_EMRSCALEWINDOWEXTEX_safe(record);        break;
+        case U_EMR_SAVEDC:                  rstatus=U_EMRSAVEDC_safe(record);                  break;
+        case U_EMR_RESTOREDC:               rstatus=U_EMRRESTOREDC_safe(record);               break;
+        case U_EMR_SETWORLDTRANSFORM:       rstatus=U_EMRSETWORLDTRANSFORM_safe(record);       break;
+        case U_EMR_MODIFYWORLDTRANSFORM:    rstatus=U_EMRMODIFYWORLDTRANSFORM_safe(record);    break;
+        case U_EMR_SELECTOBJECT:            rstatus=U_EMRSELECTOBJECT_safe(record);            break;
+        case U_EMR_CREATEPEN:               rstatus=U_EMRCREATEPEN_safe(record);               break;
+        case U_EMR_CREATEBRUSHINDIRECT:     rstatus=U_EMRCREATEBRUSHINDIRECT_safe(record);     break;
+        case U_EMR_DELETEOBJECT:            rstatus=U_EMRDELETEOBJECT_safe(record);            break;
+        case U_EMR_ANGLEARC:                rstatus=U_EMRANGLEARC_safe(record);                break;
+        case U_EMR_ELLIPSE:                 rstatus=U_EMRELLIPSE_safe(record);                 break;
+        case U_EMR_RECTANGLE:               rstatus=U_EMRRECTANGLE_safe(record);               break;
+        case U_EMR_ROUNDRECT:               rstatus=U_EMRROUNDRECT_safe(record);               break;
+        case U_EMR_ARC:                     rstatus=U_EMRARC_safe(record);                     break;
+        case U_EMR_CHORD:                   rstatus=U_EMRCHORD_safe(record);                   break;
+        case U_EMR_PIE:                     rstatus=U_EMRPIE_safe(record);                     break;
+        case U_EMR_SELECTPALETTE:           rstatus=U_EMRSELECTPALETTE_safe(record);           break;
+        case U_EMR_CREATEPALETTE:           rstatus=U_EMRCREATEPALETTE_safe(record);           break;
+        case U_EMR_SETPALETTEENTRIES:       rstatus=U_EMRSETPALETTEENTRIES_safe(record);       break;
+        case U_EMR_RESIZEPALETTE:           rstatus=U_EMRRESIZEPALETTE_safe(record);           break;
+        case U_EMR_REALIZEPALETTE:          rstatus=U_EMRREALIZEPALETTE_safe(record);          break;
+        case U_EMR_EXTFLOODFILL:            rstatus=U_EMREXTFLOODFILL_safe(record);            break;
+        case U_EMR_LINETO:                  rstatus=U_EMRLINETO_safe(record);                  break;
+        case U_EMR_ARCTO:                   rstatus=U_EMRARCTO_safe(record);                   break;
+        case U_EMR_POLYDRAW:                rstatus=U_EMRPOLYDRAW_safe(record);                break;
+        case U_EMR_SETARCDIRECTION:         rstatus=U_EMRSETARCDIRECTION_safe(record);         break;
+        case U_EMR_SETMITERLIMIT:           rstatus=U_EMRSETMITERLIMIT_safe(record);           break;
+        case U_EMR_BEGINPATH:               rstatus=U_EMRBEGINPATH_safe(record);               break;
+        case U_EMR_ENDPATH:                 rstatus=U_EMRENDPATH_safe(record);                 break;
+        case U_EMR_CLOSEFIGURE:             rstatus=U_EMRCLOSEFIGURE_safe(record);             break;
+        case U_EMR_FILLPATH:                rstatus=U_EMRFILLPATH_safe(record);                break;
+        case U_EMR_STROKEANDFILLPATH:       rstatus=U_EMRSTROKEANDFILLPATH_safe(record);       break;
+        case U_EMR_STROKEPATH:              rstatus=U_EMRSTROKEPATH_safe(record);              break;
+        case U_EMR_FLATTENPATH:             rstatus=U_EMRFLATTENPATH_safe(record);             break;
+        case U_EMR_WIDENPATH:               rstatus=U_EMRWIDENPATH_safe(record);               break;
+        case U_EMR_SELECTCLIPPATH:          rstatus=U_EMRSELECTCLIPPATH_safe(record);          break;
+        case U_EMR_ABORTPATH:               rstatus=U_EMRABORTPATH_safe(record);               break;
+        case U_EMR_UNDEF69:                 rstatus=U_EMRUNDEF69_safe(record);                 break;
+        case U_EMR_COMMENT:                 rstatus=U_EMRCOMMENT_safe(record);                 break;
+        case U_EMR_FILLRGN:                 rstatus=U_EMRFILLRGN_safe(record);                 break;
+        case U_EMR_FRAMERGN:                rstatus=U_EMRFRAMERGN_safe(record);                break;
+        case U_EMR_INVERTRGN:               rstatus=U_EMRINVERTRGN_safe(record);               break;
+        case U_EMR_PAINTRGN:                rstatus=U_EMRPAINTRGN_safe(record);                break;
+        case U_EMR_EXTSELECTCLIPRGN:        rstatus=U_EMREXTSELECTCLIPRGN_safe(record);        break;
+        case U_EMR_BITBLT:                  rstatus=U_EMRBITBLT_safe(record);                  break;
+        case U_EMR_STRETCHBLT:              rstatus=U_EMRSTRETCHBLT_safe(record);              break;
+        case U_EMR_MASKBLT:                 rstatus=U_EMRMASKBLT_safe(record);                 break;
+        case U_EMR_PLGBLT:                  rstatus=U_EMRPLGBLT_safe(record);                  break;
+        case U_EMR_SETDIBITSTODEVICE:       rstatus=U_EMRSETDIBITSTODEVICE_safe(record);       break;
+        case U_EMR_STRETCHDIBITS:           rstatus=U_EMRSTRETCHDIBITS_safe(record);           break;
+        case U_EMR_EXTCREATEFONTINDIRECTW:  rstatus=U_EMREXTCREATEFONTINDIRECTW_safe(record);  break;
+        case U_EMR_EXTTEXTOUTA:             rstatus=U_EMREXTTEXTOUTA_safe(record);             break;
+        case U_EMR_EXTTEXTOUTW:             rstatus=U_EMREXTTEXTOUTW_safe(record);             break;
+        case U_EMR_POLYBEZIER16:            rstatus=U_EMRPOLYBEZIER16_safe(record);            break;
+        case U_EMR_POLYGON16:               rstatus=U_EMRPOLYGON16_safe(record);               break;
+        case U_EMR_POLYLINE16:              rstatus=U_EMRPOLYLINE16_safe(record);              break;
+        case U_EMR_POLYBEZIERTO16:          rstatus=U_EMRPOLYBEZIERTO16_safe(record);          break;
+        case U_EMR_POLYLINETO16:            rstatus=U_EMRPOLYLINETO16_safe(record);            break;
+        case U_EMR_POLYPOLYLINE16:          rstatus=U_EMRPOLYPOLYLINE16_safe(record);          break;
+        case U_EMR_POLYPOLYGON16:           rstatus=U_EMRPOLYPOLYGON16_safe(record);           break;
+        case U_EMR_POLYDRAW16:              rstatus=U_EMRPOLYDRAW16_safe(record);              break;
+        case U_EMR_CREATEMONOBRUSH:         rstatus=U_EMRCREATEMONOBRUSH_safe(record);         break;
+        case U_EMR_CREATEDIBPATTERNBRUSHPT: rstatus=U_EMRCREATEDIBPATTERNBRUSHPT_safe(record); break;
+        case U_EMR_EXTCREATEPEN:            rstatus=U_EMREXTCREATEPEN_safe(record);            break;
+        case U_EMR_POLYTEXTOUTA:            rstatus=U_EMRPOLYTEXTOUTA_safe(record);            break;
+        case U_EMR_POLYTEXTOUTW:            rstatus=U_EMRPOLYTEXTOUTW_safe(record);            break;
+        case U_EMR_SETICMMODE:              rstatus=U_EMRSETICMMODE_safe(record);              break;
+        case U_EMR_CREATECOLORSPACE:        rstatus=U_EMRCREATECOLORSPACE_safe(record);        break;
+        case U_EMR_SETCOLORSPACE:           rstatus=U_EMRSETCOLORSPACE_safe(record);           break;
+        case U_EMR_DELETECOLORSPACE:        rstatus=U_EMRDELETECOLORSPACE_safe(record);        break;
+        case U_EMR_GLSRECORD:               rstatus=U_EMRGLSRECORD_safe(record);               break;
+        case U_EMR_GLSBOUNDEDRECORD:        rstatus=U_EMRGLSBOUNDEDRECORD_safe(record);        break;
+        case U_EMR_PIXELFORMAT:             rstatus=U_EMRPIXELFORMAT_safe(record);             break;
+        case U_EMR_DRAWESCAPE:              rstatus=U_EMRDRAWESCAPE_safe(record);              break;
+        case U_EMR_EXTESCAPE:               rstatus=U_EMREXTESCAPE_safe(record);               break;
+        case U_EMR_UNDEF107:                rstatus=U_EMRUNDEF107_safe(record);                break;
+        case U_EMR_SMALLTEXTOUT:            rstatus=U_EMRSMALLTEXTOUT_safe(record);            break;
+        case U_EMR_FORCEUFIMAPPING:         rstatus=U_EMRFORCEUFIMAPPING_safe(record);         break;
+        case U_EMR_NAMEDESCAPE:             rstatus=U_EMRNAMEDESCAPE_safe(record);             break;
+        case U_EMR_COLORCORRECTPALETTE:     rstatus=U_EMRCOLORCORRECTPALETTE_safe(record);     break;
+        case U_EMR_SETICMPROFILEA:          rstatus=U_EMRSETICMPROFILEA_safe(record);          break;
+        case U_EMR_SETICMPROFILEW:          rstatus=U_EMRSETICMPROFILEW_safe(record);          break;
+        case U_EMR_ALPHABLEND:              rstatus=U_EMRALPHABLEND_safe(record);              break;
+        case U_EMR_SETLAYOUT:               rstatus=U_EMRSETLAYOUT_safe(record);               break;
+        case U_EMR_TRANSPARENTBLT:          rstatus=U_EMRTRANSPARENTBLT_safe(record);          break;
+        case U_EMR_UNDEF117:                rstatus=U_EMRUNDEF117_safe(record);                break;
+        case U_EMR_GRADIENTFILL:            rstatus=U_EMRGRADIENTFILL_safe(record);            break;
+        case U_EMR_SETLINKEDUFIS:           rstatus=U_EMRSETLINKEDUFIS_safe(record);           break;
+        case U_EMR_SETTEXTJUSTIFICATION:    rstatus=U_EMRSETTEXTJUSTIFICATION_safe(record);    break;
+        case U_EMR_COLORMATCHTOTARGETW:     rstatus=U_EMRCOLORMATCHTOTARGETW_safe(record);     break;
+        case U_EMR_CREATECOLORSPACEW:       rstatus=U_EMRCREATECOLORSPACEW_safe(record);       break;
+        default:                            rstatus=U_EMRNOTIMPLEMENTED_safe(record);          break;
+    }  //end of switch
+    return(rstatus);
+}
+
+
+#ifdef __cplusplus
+}
+#endif