glue_ulong.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2012 Ocean Blue Software Ltd
 *
 * 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 "glue_ulong.h"

/*---constant definitions for this file--------------------------------------*/


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

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

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

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


#ifndef USE_TRUE_64BIT

U64BIT ULONG_Add(U64BIT variable, U64BIT value)
{
   U32BIT t = variable.l;

   variable.l += value.l;
   if (variable.l < t)
   {
      /* overflow */
      ++variable.h;
   }
   variable.h += value.h;
   return variable;
}

U64BIT ULONG_Add32(U64BIT variable, U32BIT value)
{
   U32BIT t = variable.l;

   variable.l += value;
   if (variable.l < t)
   {
      /* overflow */
      ++variable.h;
   }
   return variable;
}

U64BIT ULONG_Sub(U64BIT variable, U64BIT value)
{
   U32BIT c;

   c = (value.l > variable.l);
   variable.l -= value.l;
   variable.h -= value.h;
   variable.h -= c;
   return variable;
}

U64BIT ULONG_Sub32(U64BIT variable, U32BIT value)
{
   U32BIT c;

   c = (value > variable.l);
   variable.l -= value;
   variable.h -= c;
   return variable;
}

U64BIT ULONG_Mul32(U64BIT variable, U32BIT value)
{
   U32BIT t0, t1, t2, t3, t4, t5, t6, c, hw;
   U16BIT a0, a1, a2, a3;
   U16BIT b0, b1;

   /*
    *            6  5  4  3  2  1  0
    *
    *                    a3 a2 a1 a0
    *                          b1 b0   tmp
    *            -------------------   ---
    *                          a0xb0   0
    *                       a1xb0      1
    *                    a2xb0         2
    *                 a3xb0            3
    *                       a0xb1      4
    *                    a1xb1         5
    *                 a2xb1            6
    *              a3xb1               7  -- unused
    *           --------------------
    */

   a0 = variable.l & 0xffffU;
   a1 = (variable.l >> 16) & 0xffffU;
   a2 = variable.h & 0xffffU;
   a3 = (variable.h >> 16) & 0xffffU;
   b0 = value & 0xffffU;
   b1 = (value >> 16) & 0xffffU;

   t0 = b0 * a0;
   t1 = b0 * a1;
   t2 = b0 * a2;
   t3 = b0 * a3;

   t4 = b1 * a0;
   t5 = b1 * a1;
   t6 = b1 * a2;
   /* t7 = b1 * a3; -- unused */

   c = 0;

   /* Calculate variable.l and remember the carry */
   variable.l = t0;
   hw = (t1 << 16) & 0xffff0000U;
   c += (variable.l + hw < variable.l);
   variable.l += hw;
   hw = (t4 << 16) & 0xffff0000U;
   c += (variable.l + hw < variable.l);
   variable.l += hw;

   /* Avoid issues with 64-bit processors */
   variable.l &= 0xffffffffU;

   /* Calculate variable.h */
   variable.h = (t1 >> 16) + t2 + (t3 << 16) + (t4 >> 16) + t5 + (t6 << 16) + c;

   /* Avoid issues with 64-bit processors */
   variable.h &= 0xffffffffU;

   return variable;
}

U64BIT ULONG_Div32(U64BIT variable, U32BIT value)
{
   U32BIT m, p, acc;

   /* Calculate MSW */
   p = variable.h;
   m = variable.h % value;
   variable.h = (p - m) / value;

   /* Calculate LSW (one byte at a time) */
   m = ((m << 8) | ((variable.l >> 24) & 0xff)) & 0xffffffffU;
   p = m;
   m %= value;
   acc = (p - m) / value;

   m = ((m << 8) | ((variable.l >> 16) & 0xff)) & 0xffffffffU;
   p = m;
   m %= value;
   acc = acc * 256 + (p - m) / value;

   m = ((m << 8) | ((variable.l >> 8) & 0xff)) & 0xffffffffU;
   p = m;
   m %= value;
   acc = acc * 256 + (p - m) / value;

   m = ((m << 8) | (variable.l & 0xff)) & 0xffffffffU;
   p = m;
   m %= value;
   acc = acc * 256 + (p - m) / value;

   variable.l = acc;

   return variable;
}

U64BIT ULONG_ShiftLeft(U64BIT variable, U32BIT value)
{
   U32BIT c;
   if (value > 63)
   {
      variable.l = 0;
      variable.h = 0;
   }
   else if (value > 31)
   {
      variable.h = variable.l;
      variable.h <<= value - 32;
      variable.l = 0;
   }
   else
   {
      c = variable.l >> (32 - value);
      variable.h <<= value;
      variable.h |= c;
      variable.l <<= value;
   }
   return variable;
}

U64BIT ULONG_ShiftRight(U64BIT variable, U32BIT value)
{
   U32BIT c;
   if (value > 63)
   {
      variable.l = 0;
      variable.h = 0;
   }
   else if (value > 31)
   {
      variable.l = variable.h;
      variable.l >>= value - 32;
      variable.h = 0;
   }
   else
   {
      c = variable.h << (32 - value);
      variable.l >>= value;
      variable.l |= c;
      variable.h >>= value;
   }
   return variable;
}

U32BIT ULONG_Mod32(U64BIT variable, U32BIT value)
{
   U32BIT acc;

   acc = variable.h % value;
   acc = (acc << 8 | ((variable.l >> 24) & 0xff)) % value;
   acc = (acc << 8 | ((variable.l >> 16) & 0xff)) % value;
   acc = (acc << 8 | ((variable.l >> 8) & 0xff)) % value;
   acc = (acc << 8 | (variable.l & 0xff)) % value;

   return acc;
}

S32BIT ULONG_Compare(U64BIT first, U64BIT second)
{
   S32BIT cmp;

   /* Avoid problems with signed/unsigned, 64 bit values etc.
    * Just do a simple, portable, straight-forward comparison.
    */
   if (first.h > second.h)
   {
      cmp = 1;
   }
   else if (first.h == second.h)
   {
      if (first.l > second.l)
      {
         cmp = 1;
      }
      else if (first.l == second.l)
      {
         cmp = 0;
      }
      else
      {
         cmp = -1;
      }
   }
   else
   {
      cmp = -1;
   }

   return cmp;
}

S32BIT ULONG_Compare32(U64BIT variable, U32BIT value)
{
   S32BIT cmp;

   /* Avoid problems with signed/unsigned, 64 bit values etc.
    * Just do a simple, portable, straight-forward comparison.
    */
   if (variable.h > 0)
   {
      cmp = 1;
   }
   else if (variable.l > value)
   {
      cmp = 1;
   }
   else if (variable.l == value)
   {
      cmp = 0;
   }
   else
   {
      cmp = -1;
   }

   return cmp;
}

U64BIT ULONG_Atoi(char *str)
{
   U64BIT variable;
   variable.l = 0;
   variable.h = 0;

   if (*str >= '0' && *str <= '9')
   {
      variable.l = *str - '0';
      str++;
   }

   while (*str >= '0' && *str <= '9')
   {
      variable = ULONG_Mul32(variable, 10);
      variable = ULONG_Add32(variable, *str - '0');
      str++;
   }
   return variable;
}

void ULONG_Itoa(U64BIT variable, char *str)
{
   char local[MAX_64BIT_DECIMAL_STRING];
   U64BIT tmp;
   int p;

   if (variable.l == 0 && variable.h == 0)
   {
      /* Special case */
      str[0] = '0';
      str[1] = '\0';
   }
   else
   {
      /* Slow and painful */
      tmp = variable;
      p = 0;
      while (tmp.l != 0 || tmp.h != 0)
      {
         /* Using mod rules and the fact that 2**32 mod 10 = 6 */
         local[p] = '0' + (6 * (tmp.h % 10) + (tmp.l % 10)) % 10;
         tmp = ULONG_Div32(tmp, 10);
         ++p;
      }

      /* Result is reversed */
      str[p] = '\0';
      do
      {
         --p;
         *str = local[p];
         ++str;
      }
      while (p > 0);
   }
}

#else /*USE_TRUE_64BIT*/


U64BIT ULONG_Atoi(char *str )
{
   U64BIT variable = 0;
   if (*str >= '0' && *str <= '9')
   {
      variable = *str - '0';
      str++;
   }
   while (*str >= '0' && *str <= '9')
   {
      variable *= 10;
      variable += *str - '0';
      str++;
   }
   return variable;
}

void ULONG_Itoa(U64BIT variable, char *str)
{
   char local[MAX_64BIT_DECIMAL_STRING];
   int p;

   if (variable == 0)
   {
      /* Special case */
      str[0] = '0';
      str[1] = '\0';
   }
   else
   {
      /* Slow and painful */
      p = 0;
      while (variable != 0)
      {
         local[p] = '0' + variable % 10;
         variable /= 10;
         ++p;
      }

      /* Result is reversed */
      str[p] = '\0';
      do
      {
         --p;
         *str = local[p];
         ++str;
      }
      while (p > 0);
   }
}

#endif /*USE_TRUE_64BIT*/