mh5base.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2004 Ocean Blue Software Ltd
 * Copyright © 2000 Koninklijke Philips Electronics N.V
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 *
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 *
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
/*---includes for this file--------------------------------------------------*/
#include "mh5memory.h"
#include "mh5base.h"
#include "mh5debug.h"
#include "stb_os.h"

#include <string.h>
#include <stdlib.h>

#ifdef MH5PRINTOUT
#include <stdio.h>
#include "mh5eventtokens.h"
#include "mh5group.h"
#include "mh5application.h"
#include "dsm_types.h"
#endif

/*---constant definitions for this file--------------------------------------*/
#ifdef MH5PRINTOUT
#define MHEG5CP_DEFAULT 127
#endif

/*---local typedef structs for this file-------------------------------------*/

/*---local (static) variable declarations for this file----------------------*/

#ifdef MH5PRINTOUT
static int indent = 0;
#endif

/*---local function definitions----------------------------------------------*/

/*---global function definitions---------------------------------------------*/

#ifdef MH5PRINTOUT

void MHEG5indent(char *out)
{
   int i;

   for (i = 0; i < indent; i++)
   {
      MHEG_PRINT(out, "  ");
   }
}

int MHEG5setIndent(int i)
{
   int rtn = indent;
   indent = i;
   return rtn;
}

void MHEG5incIndent(void)
{
   indent++;
}

void MHEG5decIndent(void)
{
   indent--;
}

void MHEG5newLine(char *out)
{
   MHEG_PRINT(out, "\n");
}

void MHEG5classPrint(MHEG5Final class, char *out)
{
   switch (class)
   {
      case MHEG5SCENE:
         MHEG_PRINT(out, "{ :Scene");
         break;
      case MHEG5APPLICATION:
         MHEG_PRINT(out, "{ :Application");
         break;
      case MHEG5LINK:
         MHEG_PRINT(out, "{ :Link");
         break;
      case MHEG5PALETTE:
         MHEG_PRINT(out, "{ :Palette");
         break;
      case MHEG5CURSORSHAPE:
         MHEG_PRINT(out, "{ :Cursorshape");
         break;
      case MHEG5FONT:
         MHEG_PRINT(out, "{ :Font");
         break;
      case MHEG5RESIDENTPROGRAM:
         MHEG_PRINT(out, "{ :ResidentPrg");
         break;
      case MHEG5REMOTEPROGRAM:
         MHEG_PRINT(out, "{ :Remoteprogram");
         break;
      case MHEG5INTERCHANGEDPROGRAM:
         MHEG_PRINT(out, "{ :Interchangedprogram");
         break;
      case MHEG5BOOLEANVARIABLE:
         MHEG_PRINT(out, "{ :BooleanVar");
         break;
      case MHEG5INTEGERVARIABLE:
         MHEG_PRINT(out, "{ :IntegerVar");
         break;
      case MHEG5OCTETSTRINGVARIABLE:
         MHEG_PRINT(out, "{ :OStringVar");
         break;
      case MHEG5OBJECTREFVARIABLE:
         MHEG_PRINT(out, "{ :ObjectRefVar");
         break;
      case MHEG5CONTENTREFVARIABLE:
         MHEG_PRINT(out, "{ :ContentRefVar");
         break;
      case MHEG5STREAM:
         MHEG_PRINT(out, "{ :Stream");
         break;
      case MHEG5AUDIO:
         MHEG_PRINT(out, "{ :Audio");
         break;
      case MHEG5TOKENGROUP:
         MHEG_PRINT(out, "{ :Tokengroup");
         break;
      case MHEG5LISTGROUP:
         MHEG_PRINT(out, "{ :Listgroup");
         break;
      case MHEG5RTGRAPHICS:
         MHEG_PRINT(out, "{ :Rtgraphics");
         break;
      case MHEG5LINEART:
         MHEG_PRINT(out, "{ :Lineart");
         break;
      case MHEG5BITMAP:
         MHEG_PRINT(out, "{ :Bitmap");
         break;
      case MHEG5TEXT:
         MHEG_PRINT(out, "{ :Text");
         break;
      case MHEG5VIDEO:
         MHEG_PRINT(out, "{ :Video");
         break;
      case MHEG5SLIDER:
         MHEG_PRINT(out, "{ :Slider");
         break;
      case MHEG5DYNAMICLINEART:
         MHEG_PRINT(out, "{ :Dynamiclineart");
         break;
      case MHEG5RECTANGLE:
         MHEG_PRINT(out, "{ :Rectangle");
         break;
      case MHEG5ENTRYFIELD:
         MHEG_PRINT(out, "{ :Entryfield");
         break;
      case MHEG5HYPERTEXT:
         MHEG_PRINT(out, "{ :Hypertext");
         break;
      case MHEG5HOTSPOT:
         MHEG_PRINT(out, "{ :Hotspot");
         break;
      case MHEG5PUSHBUTTON:
         MHEG_PRINT(out, "{ :Pushbutton");
         break;
      case MHEG5SWITCHBUTTON:
         MHEG_PRINT(out, "{ :Switchbutton");
         break;
      default:
         MHEG_PRINT(out, "{:InternalError");
         break;
   }
}

#endif  /* #ifdef MH5PRINTOUT */

#if defined(MHEG5LOG) || defined(MH5PRINTOUT)

/* The following are even when MH5PRINTOUT is not defined */

void MHEG5eventPrint(MHEG5EventType e, char *out)
{
   MHEG_PRINT(out, MHEG5eventToString(e));
}

void MHEG5stringPrint(MHEG5String s, char *out)
{
   char buff[1024];
   int i, j;

   j = 0;
   for (i = 0; i != s.len && j < 1020; i++)
   {
      if ((s.data[i] >= ' ' && s.data[i] < '=') ||
          (s.data[i] > '=' && s.data[i] <= 127) ||
          s.data[i] == 0x09)
      {
         buff[j++] = s.data[i];
      }
      else
      {
         buff[j++] = '=';
         buff[j++] = (s.data[i] >> 4) < 10 ? (s.data[i] >> 4) + '0' : (s.data[i] >> 4) + 'A' - 10;
         buff[j++] = (s.data[i] & 0x0F) < 10 ? (s.data[i] & 0x0F) + '0' : (s.data[i] & 0x0F) + 'A' - 10;
      }
   }
   buff[j] = '\0';
   MHEG_PRINT(out, "'");
   MHEG_PRINT(out, buff);
   MHEG_PRINT(out, "'");
}

void MHEG5octetPrint(MHEG5String s, char *out)
{
   char buff[128];
   int i, j;

   j = 0;
   for (i = 0; i != s.len && j < 124; i++)
   {
      buff[j++] = '=';
      buff[j++] = (s.data[i] >> 4) < 10 ? (s.data[i] >> 4) + '0' : (s.data[i] >> 4) + 'A' - 10;
      buff[j++] = (s.data[i] & 0x0F) < 10 ? (s.data[i] & 0x0F) + '0' : (s.data[i] & 0x0F) + 'A' - 10;
   }
   buff[j] = '\0';
   MHEG_PRINT(out, "'");
   MHEG_PRINT(out, buff);
   MHEG_PRINT(out, "'");
}

void MHEG5objectrefPrint(MHEG5ObjectReference o, char *out)
{
   if (o.gref.len)
   {
      MHEG_PRINT(out, "(");
      MHEG5stringPrint( *((MHEG5String *)&o.gref), out );
      MHEG_PRINT(out, " ");
      MHEG5intPrint(o.id, out);
      MHEG_PRINT(out, ")");
   }
   else
   {
      MHEG5intPrint(o.id, out);
   }
}

void MHEG5boolPrint(MHEG5Bool b, char *out)
{
   if (b)
   {
      MHEG_PRINT(out, "TRUE");
   }
   else
   {
      MHEG_PRINT(out, "FALSE");
   }
}

static MHEG5Root* FindObject(MH5GroupRef gref, MHEG5Int id)
{
   MHEG5Ingredient *search = 0;
   MH5GroupPtr pGroup;

   pGroup = gref.ptr.group;
   if (pGroup && gref.len == 0)
   {
      search = pGroup->hashIngred[id & 0xff];
      while (search && (search->root.id != id))
      {
         search = search->hnxt;
      }
   }
   else
   {
      pGroup = (MH5GroupPtr)MHEG5getCurrentApplication();
      if (pGroup)
      {
         search = pGroup->hashIngred[id & 0xff];
         while (search && (search->root.id != id))
         {
            search = search->hnxt;
         }
      }
   }
   return (MHEG5Root *) search;
}

void MHEG5genericPrint(MHEG5Generic g, char *out, U8BIT dotype)
{
   switch (g.type)
   {
      case MHEG5NONE:
         //MHEG_PRINT(out,"");
         break;
      case MHEG5INT:
         if (dotype == 1)
            MHEG_PRINT(out, ":GInteger ");
         if (g.indirect)
            MHEG_PRINT(out, ":IndirectRef ");
         MHEG5intPrint(g.value.i, out);
         break;
      case MHEG5BOOL:
         if (dotype == 1)
            MHEG_PRINT(out, ":GBoolean ");
         if (g.indirect)
            MHEG_PRINT(out, ":IndirectRef ");
         MHEG5boolPrint(g.value.b, out);
         break;
      case MHEG5NULL:
         //MHEG_PRINT(out,"");
         break;
      case MHEG5OCTETSTRING:
         if (dotype == 1)
            MHEG_PRINT(out, ":GOctetString ");
         if (g.indirect)
            MHEG_PRINT(out, ":IndirectRef ");
         MHEG5stringPrint(g.value.s, out);
         break;
      case MHEG5BRACKETOPEN:
         MHEG_PRINT(out, "(");
         break;
      case MHEG5BRACKETCLOSE:
         MHEG_PRINT(out, ")");
         break;
      case MHEG5EVENT:
         MHEG5eventPrint(g.value.e, out);
         break;
      case MHEG5INTPAIR:
         MHEG5intPrint(g.value.p.x, out);
         MHEG_PRINT(out, " ");
         MHEG5intPrint(g.value.p.y, out);
         break;
      case MHEG5OBJREFEXT:
      case MHEG5OBJECTREF:
         //MHEG_PRINT(out,":GObjectRef ");
         //if (g.indirect) MHEG_PRINT(out,":IndirectRef ");
         if (g.indirect)
         {
            if (dotype)
            {
               MHEG5Root *object;
               object = FindObject(g.value.o.gref, g.value.o.id);
               if (object)
               {
                  switch (object->clazz)
                  {
                     case MHEG5BOOLEANVARIABLE:
                        MHEG_PRINT(out, ":GBoolean ");
                        break;
                     case MHEG5OCTETSTRINGVARIABLE:
                        if (dotype == 1)
                        {
                           MHEG_PRINT(out, ":GOctetString ");
                        }
                        else if (dotype == 4)
                        {
                           MHEG_PRINT(out, ":NewAbsoluteColour ");
                        }
                        break;
                     case MHEG5INTEGERVARIABLE:
                        MHEG_PRINT(out, ":GInteger ");
                        break;
                     case MHEG5OBJECTREFVARIABLE:
                        MHEG_PRINT(out, ":GObjectRef ");
                        break;
                     case MHEG5CONTENTREFVARIABLE:
                        if (dotype == 2)
                        {
                           MHEG_PRINT(out, ":NewRefContent (");
                           dotype++;
                        }
                        else
                        {
                           MHEG_PRINT(out, ":GContentRef ");
                        }
                        break;
                     default:;
                  }
               }
            }
            MHEG_PRINT(out, ":IndirectRef ");
         }
         else if (dotype)
         {
            MHEG_PRINT(out, ":GObjectRef ");
         }
         MHEG5objectrefPrint(g.value.o, out);
         //if ( dotype == 3 )
         //{
         //   MHEG_PRINT(out," )");
         //}
         break;
      case MHEG5CONTENTREF:
         MHEG_PRINT(out, ":NewRefContent (");
         MHEG5stringPrint(g.value.s, out);
         break;
      default:
         MHEG_PRINT(out, "// :InternalError ");
         break;
   }
}

void MHEG5colourPrint(MHEG5Colour c, char *out)
{
   switch (c.type)
   {
      case MHEG5INT:
         MHEG5hexPrint(c.value.i, out);
         break;
      case MHEG5OCTETSTRING:
         MHEG5octetPrint(c.value.s, out);
         break;
      default:
         MHEG_PRINT(out, "??");
         break;
   }
}

void MHEG5gListPrint(MHEG5GList *l, char *out, U8BIT noTypeCnt)
{
   U8BIT count = 1;
   do
   {
      MHEG5genericPrint(l->generic, out, (count > noTypeCnt) ? 1 : 0);
      MHEG_PRINT(out, " ");
      l++;
      count++;
   }
   while (!l->generic.isfirst);
}

void MHEG5sdListPrint(MHEG5GList *l, char *out)
{
   MHEG5genericPrint(l->generic, out, 0);
   MHEG_PRINT(out, " ");
   l++;
   if (l->generic.type == MHEG5CONTENTREF)
   {
      MHEG5genericPrint(l->generic, out, 0);
      MHEG_PRINT(out, " ");
      l++;
      if (!l->generic.isfirst)
      {
         l++; // skip 'new size'
         if (!l->generic.isfirst &&
             l->generic.type == MHEG5INT &&
             l->generic.value.i != MHEG5CP_DEFAULT)
         {
            MHEG_PRINT(out, " :NewCCPriority ");
            MHEG5intPrint(l->generic.value.i, out);
         }
      }
      MHEG_PRINT(out, " )");
   }
   else
   {
      do
      {
         MHEG5genericPrint(l->generic, out, 2);
         MHEG_PRINT(out, " ");
         l++;
      }
      while (!l->generic.isfirst);
   }
}

void MHEG5clrListPrint(MHEG5GList *l, char *out)
{
   MHEG5genericPrint(l->generic, out, FALSE);
   MHEG_PRINT(out, " ");
   l++;
   do
   {
      MHEG5genericPrint(l->generic, out, 4);
      MHEG_PRINT(out, " ");
      l++;
   }
   while (!l->generic.isfirst);
}

void MHEG5cListPrint(MHEG5GList *l, char *out)
{
   MHEG5genericPrint(l->generic, out, 0);
   MHEG_PRINT(out, " ");
   l++;
   MHEG5genericPrint(l->generic, out, 0);
   MHEG_PRINT(out, " ");
   l++;
   indent += 4;
   do
   {
      if (l->generic.type != MHEG5NONE)
      {
         MHEG5newLine(out);
         MHEG5indent(out);
         MHEG5genericPrint(l->generic, out, 1);
         MHEG_PRINT(out, " ");
      }
      l++;
   }
   while (!l->generic.isfirst);
   indent -= 4;
   MHEG5newLine(out);
   MHEG5indent(out);
}

#endif  /* #ifdef MHEG5LOG || MH5PRINTOUT */


#ifdef MHEG5LOG
/*
     String Functions
 */
char* MHEG5stringGet(MHEG5String source) {
   char *rc;

   rc = MHEG5getMem( source.len + 1 );
   assert(rc);
   if (rc != 0)
   {
      memcpy(rc, source.data, source.len);
      rc[source.len] = '\0';
   }
   return rc;
}

#endif


#ifdef MHG_TRACK_MEM
MHEG5String MHEG5stringCopyFunc(MHEG5String source, int line )
#else
MHEG5String MHEG5stringCopy(MHEG5String source)
#endif
{
   MHEG5String rc;

   if (source.len != 0)
   {
      #ifdef MHG_TRACK_MEM
      rc.data = STR_DataAllocFunc( source.len, line + 5000 );
      #else
      rc.data = STR_DataAlloc( source.len );
      #endif
      if (rc.data)
      {
         assert(rc.data != source.data);
         memcpy(rc.data, source.data, source.len);
         rc.len = source.len;
      }
      else
      {
         rc.len = 0;
      }
   }
   else
   {
      rc.data = NULL;
      rc.len = 0;
   }
   return rc;
}

MHEG5String MHEG5stringCopyChr(const char *source)
{
   MHEG5String rc;

   /* Determine the length of the string to copy */
   rc.len = strlen(source);

   if (rc.len == 0)
   {
      rc.data = NULL;
   }
   else
   {
      /* Allocate some memory for the string data */
      rc.data = STR_DataAlloc( rc.len );
      if (rc.data == NULL)
      {
         /* Alloc failed. Set the length to 0 and return */
         rc.len = 0;
      }
      else
      {
         memcpy(rc.data, source, rc.len);
      }
   }
   return rc;
}

MHEG5String MHEG5stringCat(MHEG5String source1, MHEG5String source2)
{
   MHEG5String rc;

   if (source1.len + source2.len == 0)
   {
      rc.len = 0;
      rc.data = NULL;
   }
   else
   {
      rc.data = STR_DataAlloc( source1.len + source2.len );
      if (rc.data == NULL)
      {
         rc.len = 0;
      }
      else
      {
         if (source1.len > 0)
         {
            memcpy(rc.data, source1.data, source1.len);
         }
         if (source2.len > 0)
         {
            memcpy(&rc.data[source1.len], source2.data, source2.len);
         }
         rc.len = source1.len + source2.len;
      }
   }
   return rc;
}

void MHEG5stringDestruct(MHEG5String *item)
{
   /* Note: even zero length string gets an allocation */
   if (item->data != NULL)
   {
      /*TRACE(TFILE,("destoy string %.*s",(int)item->len,item->data))*/
      STR_DataFree( item->data, item->len );
      item->data = NULL;
      item->len = 0;
   }
}

/*
     Compare Strings - not case sensitive!
 */

MHEG5Bool MHEG5stringEqual(MHEG5String *s1, MHEG5String *s2)
{
   if (s1->len != s2->len)
   {
      /* Lengths do not match, so strings cannot be equal. */
      return MHEG5FALSE;
   }

   if (s1->data == s2->data)
   {
      /* If the data pointer is equal, the strings must be equal */
      return MHEG5TRUE;             /* Always TRUE  */
   }

   if (memcmp(s1->data, s2->data, s1->len) != 0)
   {
      return MHEG5FALSE;
   }

   return MHEG5TRUE;
}

MHEG5Int MHEG5strToInt(MHEG5String string)
{
   register int i, mp = 1, j = 0;
   register int rc = 0;

   if (!string.len)
      return 0;
   if ((string.len > 1) && ((string.data[1] == 'x') || (string.data[1] == 'X')))    /* HEX INT  */
   {
      for (i = 2; i < string.len; i++)
         if ((string.data[i] >= '0') && (string.data[i] <= '9'))
            rc = rc * 16 + ((int) string.data[i] - (int) '0');
         else if ((string.data[i] >= 'a') && (string.data[i] <= 'z'))
            rc = rc * 16 + ((int) string.data[i] - (int) 'a') + 10;
         else if ((string.data[i] >= 'A') && (string.data[i] <= 'Z'))
            rc = rc * 16 + ((int) string.data[i] - (int) 'A') + 10;
         else
            break;
      return rc;
   }
   /*
        DEZ INT
    */
   if (string.data[0] == '-')
   {
      mp = -1;
      j = 1;
   }  /* negativ value  */
   if (string.data[0] == '+')
   {
      mp = 1;
      j = 1;
   }  /* explicit positiv value */
   for (i = j; i < string.len; i++)
      if ((string.data[i] >= '0') && (string.data[i] <= '9'))
         rc = rc * 10 + ((int) string.data[i] - (int) '0');
      else
         break;
   return mp * rc;
}

MHEG5String MHEG5intToStr(MHEG5Int i)
{
   char buf[100];
   register int pos = 0, jj, sgn = 0;
   MHEG5String rc;

   buf[0] = '\0';
   if (i < (MHEG5Int)0)
   {
      sgn = 1;
   }
   while (i != (MHEG5Int)0)
   {
      jj = i % 10;
      i = i / 10;
      buf[pos++] = (char) (abs(jj) + (int) '0');
   }
   if (!pos)
   {
      buf[pos++] = '0';
   }
   else if (sgn)
   {
      buf[pos++] = '-';
   }
   rc.data = STR_DataAlloc( pos );
   if (!rc.data)
   {
      rc.len = 0;
   }
   else
   {
      for (jj = 0; jj < pos; jj++)
      {
         rc.data[jj] = buf[pos - 1 - jj];
      }
      rc.len = pos;
   }
   return rc;
}

void MHEG5genericDestruct(MHEG5Generic *item)
{
   assert(item);
   switch (item->type)
   {
      case MHEG5OCTETSTRING:
      case MHEG5CONTENTREF:
         if (!item->indirect)
         {
            MHEG5stringDestruct(&item->value.s);
         }
         break;
      case MHEG5OBJREFEXT:
         MHEG5stringDestruct((MHEG5String *)(&item->value.o.gref));
         break;
      default:
         ;
   }
}

void MHEG5genericCopy(MHEG5Generic *dest, MHEG5Generic *src)
{
   if (!dest)
   {
      return;
   }

   if (!src)
   {
      return;
   }

   *dest = *src;

   if (src->type == MHEG5OCTETSTRING)
   {
      dest->value.s = MHEG5stringCopy(src->value.s);
   }
}

MHEG5Bool MHEG5genericEqual(MHEG5Generic *g1, MHEG5Generic *g2)
{
   if (g1 == g2)
      return MHEG5TRUE;
   if (!g1)
      return MHEG5FALSE;
   if (!g2)
      return MHEG5FALSE;
   if (g1->type != g2->type)
      return MHEG5FALSE;
   if (g1->indirect != g2->indirect)
      return MHEG5FALSE;
   if (!g1->indirect)
   {
      switch (g1->type)
      {
         /* Types which have no value */
         case MHEG5NONE:
         case MHEG5OBJREFEXT:
         case MHEG5BRACKETOPEN:
         case MHEG5BRACKETCLOSE:
         case MHEG5NULL:
            return MHEG5TRUE;
         case MHEG5INT:
            return (MHEG5Bool) (g1->value.i == g2->value.i);
         case MHEG5BOOL:
            return (MHEG5Bool) ((g1->value.b != MHEG5FALSE) == (g2->value.b != MHEG5FALSE));
         case MHEG5OCTETSTRING:
            return MHEG5stringEqual(&g1->value.s, &g2->value.s);
         case MHEG5EVENT:
            return (MHEG5Bool) (g1->value.e == g2->value.e);
         default:
            return MHEG5FALSE;
      }
   }
   return MHEG5FALSE;
}

void MHEG5gListDestruct(MHEG5GList *item)
{
   assert(item);
   do
   {
      MHEG5genericDestruct(&item->generic);
      item = item->next;
   } while (item);
}

MHEG5GList* MHEG5gListCopy(MHEG5GList *list)
{
   MHEG5GList *rc = 0, *prev = 0, *dest;

   while (list)
   {
      dest = MHEG5getMem( sizeof(MHEG5GList));
      if (!dest)
         return 0;
      MHEG5genericCopy(&dest->generic, &list->generic);
      dest->next = 0;
      if (!rc)
         rc = dest;
      if (prev)
         prev->next = dest;
      prev = dest;
      list = list->next;
   }
   return rc;
}

void MHEG5genericSet(MHEG5Generic *item, MHEG5Int initialValue)
{
   assert(item);
   item->indirect = MHEG5FALSE;
   item->type = MHEG5INT;
   item->value.i = initialValue;
}

#ifdef MHG_STRNCMP

/* special WINCE routines
 */
int MHEG5strncmp(char *a, char *b, int n)
{
   int i;

   for (i = 0; i < n; i++)
   {
      if ((a[i] == 0) && (b[i] == 0))
      {
         return 0;
      }

      if (a[i] == 0)
      {
         return -1;
      }

      if (b[i] == 0)
      {
         return 1;
      }

      if (a[i] < b[i])
      {
         return -1;
      }
      else if (a[i] > b[i])
      {
         return 1;
      }
   }

   return 0;
}

#endif  /* #ifdef MHG_STRNCMP */


#ifdef MHG_STRCMP

int MHEG5strcmp(char *a, char *b)
{
   int i;

   for (i = 0;; i++)
   {
      if ((a[i] == 0) && (b[i] == 0))
      {
         return 0;
      }

      if (a[i] == 0)
      {
         return -1;
      }

      if (b[i] == 0)
      {
         return 1;
      }

      if (a[i] < b[i])
      {
         return -1;
      }
      else if (a[i] > b[i])
      {
         return 1;
      }
   }

   /* This line is never reached */
   return 0;
}

#endif  /* #ifdef MHG_STRCMP */


unsigned long MHEG5random(void)
{
   static unsigned long randval = 0;

   if (randval == 0)
   {
      /* Seed the random number generator with the current time
       */
      randval = STB_OSGetClockMilliseconds();
   }

   /* The following numbers come from NUMERICAL RECIPES IN C: THE ART OF
    * SCIENTIFIC COMPUTING (ISBN 0-521-43108-5)
    *
    * Online version available at:
    *     http://www.ulib.org/webRoot/Books/Numerical_Recipes/bookcpdf/c7-1.pdf
    */
   randval = 1664525 * randval + 1013904223;

   return randval;
}

char* MHEG5safeStrcat(char *dest, size_t destLength, const char *source)
{
   size_t destIndex;
   size_t sourceIndex;

   destIndex = strlen(dest);
   sourceIndex = 0;
   while ((source[sourceIndex] != '\0') && (destIndex < destLength - 1))
   {
      dest[destIndex] = source[sourceIndex];
      sourceIndex++;
      destIndex++;
   }
   dest[destIndex] = '\0';

   return dest;
}

#if defined(_WIN32_WCE)

char tempstr[256];
TCHAR wtempstr[256];

TCHAR* StrToUnicode(char *string)
{
   MultiByteToWideChar(CP_ACP, MB_COMPOSITE, string, -1, wtempstr, 255);
   return wtempstr;
}

char* StrFromUnicode(TCHAR *string)
{
   WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK | WC_DEFAULTCHAR | WC_SEPCHARS, string, -1, tempstr, sizeof(tempstr) - 1, NULL, NULL);
   return tempstr;
}

#endif